Repository: equilibria-xyz/root
Pull request #124: Add operators to numeric types
Author: login: EdNoepel
Created: 2025-04-07T20:27:49Z | Merged: 2025-04-09T15:05:40Z

With this change, operator functions such as `fixed.add(otherFixed)` or `FixedLib.sub(fixedA, fixedB)` are no longer supported.  Instead, caller must call `fixed + otherFixed` or `fixedA - fixedB`.  This helps enforce consistent code style, and behaves similar to primitive numeric types.

Supported operators are + - * / == > < >= <= !=


Diff:
diff --git a/src/accumulator/types/Accumulator6.sol b/src/accumulator/types/Accumulator6.sol
index 45523248..134e2dfb 100644
--- a/src/accumulator/types/Accumulator6.sol
+++ b/src/accumulator/types/Accumulator6.sol
@@ -32,7 +32,7 @@ library Accumulator6Lib {
      * @param total Demoninator of the ratio (see `increment` and `decrement` functions)
      */
     function accumulated(Accumulator6 memory self, Accumulator6 memory from, UFixed6 total) internal pure returns (Fixed6) {
-        return _mul(self._value.sub(from._value), total);
+        return _mul(self._value - from._value, total);
     }
 
     /**
@@ -44,7 +44,7 @@ library Accumulator6Lib {
      */
     function increment(Accumulator6 memory self, Fixed6 amount, UFixed6 total) internal pure {
         if (amount.isZero()) return;
-        self._value = self._value.add(_div(amount, total));
+        self._value = self._value + _div(amount, total);
     }
 
     /**
@@ -56,7 +56,7 @@ library Accumulator6Lib {
      */
     function decrement(Accumulator6 memory self, Fixed6 amount, UFixed6 total) internal pure {
         if (amount.isZero()) return;
-        self._value = self._value.add(_div(amount.mul(Fixed6Lib.NEG_ONE), total));
+        self._value = self._value + _div(amount * Fixed6Lib.NEG_ONE, total);
     }
 
     /// @notice Resets the accumulator to its initial state
@@ -66,11 +66,11 @@ library Accumulator6Lib {
     }
 
     function _div(Fixed6 amount, UFixed6 total) private pure returns (Fixed6) {
-        return amount.sign() == -1 ? amount.divOut(Fixed6Lib.from(total)) : amount.div(Fixed6Lib.from(total));
+        return amount.sign() == -1 ? amount.divOut(Fixed6Lib.from(total)) : amount / Fixed6Lib.from(total);
     }
 
     function _mul(Fixed6 amount, UFixed6 total) private pure returns (Fixed6) {
-        return amount.sign() == -1 ? amount.mulOut(Fixed6Lib.from(total)) : amount.mul(Fixed6Lib.from(total));
+        return amount.sign() == -1 ? amount.mulOut(Fixed6Lib.from(total)) : amount * Fixed6Lib.from(total);
     }
 }
 
diff --git a/src/accumulator/types/UAccumulator6.sol b/src/accumulator/types/UAccumulator6.sol
index 4e7e7e04..38a04c96 100644
--- a/src/accumulator/types/UAccumulator6.sol
+++ b/src/accumulator/types/UAccumulator6.sol
@@ -30,7 +30,7 @@ library UAccumulator6Lib {
      * @param total Demoninator of the ratio (see `increment` function)
      */
     function accumulated(UAccumulator6 memory self, UAccumulator6 memory from, UFixed6 total) internal pure returns (UFixed6) {
-        return self._value.sub(from._value).mul(total);
+        return (self._value - from._value) * total;
     }
 
     /**
@@ -42,7 +42,7 @@ library UAccumulator6Lib {
      */
     function increment(UAccumulator6 memory self, UFixed6 amount, UFixed6 total) internal pure {
         if (amount.isZero()) return;
-        self._value = self._value.add(amount.div(total));
+        self._value = self._value + (amount / total);
     }
 
     /// @notice Resets the accumulator to its initial state
diff --git a/src/number/NumberMath.sol b/src/number/NumberMath.sol
index 75d3ba5e..bbcf18ff 100644
--- a/src/number/NumberMath.sol
+++ b/src/number/NumberMath.sol
@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-import "@openzeppelin/contracts/utils/math/Math.sol";
-import "@openzeppelin/contracts/utils/math/SignedMath.sol";
+import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
+import { SignedMath } from "@openzeppelin/contracts/utils/math/SignedMath.sol";
 
 /**
  * @title NumberMath
diff --git a/src/number/types/Fixed18.sol b/src/number/types/Fixed18.sol
index eba8020c..44c0a4d7 100644
--- a/src/number/types/Fixed18.sol
+++ b/src/number/types/Fixed18.sol
@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.13;
+pragma solidity ^0.8.19;
 
-import "@openzeppelin/contracts/utils/math/SignedMath.sol";
-import "../NumberMath.sol";
-import "./Fixed6.sol";
-import "./UFixed18.sol";
+import { SignedMath } from "@openzeppelin/contracts/utils/math/SignedMath.sol";
+import { NumberMath } from "../NumberMath.sol";
+import { Fixed6 } from "./Fixed6.sol";
+import { UFixed18 } from "./UFixed18.sol";
 
 /// @dev Fixed18 type
 type Fixed18 is int256;
@@ -12,6 +12,19 @@ using Fixed18Lib for Fixed18 global;
 type Fixed18Storage is bytes32;
 using Fixed18StorageLib for Fixed18Storage global;
 
+using {
+    add as +,
+    sub as -,
+    mul as *,
+    div as /,
+    eq as ==,
+    neq as !=,
+    gt as >,
+    lt as <,
+    gte as >=,
+    lte as <=
+} for Fixed18 global;
+
 /**
  * @title Fixed18Lib
  * @notice Library for the signed fixed-decimal type.
@@ -21,12 +34,12 @@ library Fixed18Lib {
     /// @custom:error Arithmetic overflow
     error Fixed18OverflowError(uint256 value);
 
-    int256 private constant BASE = 1e18;
-    Fixed18 public constant ZERO = Fixed18.wrap(0);
-    Fixed18 public constant ONE = Fixed18.wrap(BASE);
-    Fixed18 public constant NEG_ONE = Fixed18.wrap(-1 * BASE);
-    Fixed18 public constant MAX = Fixed18.wrap(type(int256).max);
-    Fixed18 public constant MIN = Fixed18.wrap(type(int256).min);
+    int256 internal constant BASE = 1e18;
+    Fixed18 internal constant ZERO = Fixed18.wrap(0);
+    Fixed18 internal constant ONE = Fixed18.wrap(BASE);
+    Fixed18 internal constant NEG_ONE = Fixed18.wrap(-1 * BASE);
+    Fixed18 internal constant MAX = Fixed18.wrap(type(int256).max);
+    Fixed18 internal constant MIN = Fixed18.wrap(type(int256).min);
 
     /**
      * @notice Creates a signed fixed-decimal from an unsigned fixed-decimal
@@ -82,8 +95,8 @@ library Fixed18Lib {
      */
     function from(Fixed18 significand, int256 exponent) internal pure returns (Fixed18) {
         return exponent < 0
-            ? significand.div(from(int256(10 ** uint256(-1 * exponent))))
-            : significand.mul(from(int256(10 ** uint256(exponent))));
+            ? significand / from(int256(10 ** uint256(-1 * exponent)))
+            : significand * from(int256(10 ** uint256(exponent)));
     }
 
     /**
@@ -95,36 +108,6 @@ library Fixed18Lib {
         return Fixed18.unwrap(a) == 0;
     }
 
-    /**
-     * @notice Adds two signed fixed-decimals `a` and `b` together
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Resulting summed signed fixed-decimal
-     */
-    function add(Fixed18 a, Fixed18 b) internal pure returns (Fixed18) {
-        return Fixed18.wrap(Fixed18.unwrap(a) + Fixed18.unwrap(b));
-    }
-
-    /**
-     * @notice Subtracts signed fixed-decimal `b` from `a`
-     * @param a Signed fixed-decimal to subtract from
-     * @param b Signed fixed-decimal to subtract
-     * @return Resulting subtracted signed fixed-decimal
-     */
-    function sub(Fixed18 a, Fixed18 b) internal pure returns (Fixed18) {
-        return Fixed18.wrap(Fixed18.unwrap(a) - Fixed18.unwrap(b));
-    }
-
-    /**
-     * @notice Multiplies two signed fixed-decimals `a` and `b` together
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Resulting multiplied signed fixed-decimal
-     */
-    function mul(Fixed18 a, Fixed18 b) internal pure returns (Fixed18) {
-        return Fixed18.wrap(Fixed18.unwrap(a) * Fixed18.unwrap(b) / BASE);
-    }
-
     /**
      * @notice Multiplies two signed fixed-decimals `a` and `b` together, rounding the result away from zero if there is a remainder
      * @param a First signed fixed-decimal
@@ -135,16 +118,6 @@ library Fixed18Lib {
         return Fixed18.wrap(NumberMath.divOut(Fixed18.unwrap(a) * Fixed18.unwrap(b), BASE));
     }
 
-    /**
-     * @notice Divides signed fixed-decimal `a` by `b`
-     * @param a Signed fixed-decimal to divide
-     * @param b Signed fixed-decimal to divide by
-     * @return Resulting divided signed fixed-decimal
-     */
-    function div(Fixed18 a, Fixed18 b) internal pure returns (Fixed18) {
-        return Fixed18.wrap(Fixed18.unwrap(a) * BASE / Fixed18.unwrap(b));
-    }
-
     /**
      * @notice Divides signed fixed-decimal `a` by `b`, rounding the result away from zero if there is a remainder
      * @param a Signed fixed-decimal to divide
@@ -233,56 +206,6 @@ library Fixed18Lib {
         return Fixed18.wrap(NumberMath.divOut(Fixed18.unwrap(a) * Fixed18.unwrap(b), Fixed18.unwrap(c)));
     }
 
-    /**
-     * @notice Returns whether signed fixed-decimal `a` is equal to `b`
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Whether `a` is equal to `b`
-     */
-    function eq(Fixed18 a, Fixed18 b) internal pure returns (bool) {
-        return compare(a, b) == 1;
-    }
-
-    /**
-     * @notice Returns whether signed fixed-decimal `a` is greater than `b`
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Whether `a` is greater than `b`
-     */
-    function gt(Fixed18 a, Fixed18 b) internal pure returns (bool) {
-        return compare(a, b) == 2;
-    }
-
-    /**
-     * @notice Returns whether signed fixed-decimal `a` is less than `b`
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Whether `a` is less than `b`
-     */
-    function lt(Fixed18 a, Fixed18 b) internal pure returns (bool) {
-        return compare(a, b) == 0;
-    }
-
-    /**
-     * @notice Returns whether signed fixed-decimal `a` is greater than or equal to `b`
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Whether `a` is greater than or equal to `b`
-     */
-    function gte(Fixed18 a, Fixed18 b) internal pure returns (bool) {
-        return gt(a, b) || eq(a, b);
-    }
-
-    /**
-     * @notice Returns whether signed fixed-decimal `a` is less than or equal to `b`
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Whether `a` is less than or equal to `b`
-     */
-    function lte(Fixed18 a, Fixed18 b) internal pure returns (bool) {
-        return lt(a, b) || eq(a, b);
-    }
-
     /**
      * @notice Compares the signed fixed-decimals `a` and `b`
      * @dev Returns: 2 for greater than
@@ -397,3 +320,105 @@ library Fixed18StorageLib {
         }
     }
 }
+
+/**
+* @notice Adds two signed fixed-decimals `a` and `b` together
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Resulting summed signed fixed-decimal
+*/
+function add(Fixed18 a, Fixed18 b) pure returns (Fixed18) {
+    return Fixed18.wrap(Fixed18.unwrap(a) + Fixed18.unwrap(b));
+}
+
+/**
+* @notice Subtracts signed fixed-decimal `b` from `a`
+* @param a Signed fixed-decimal to subtract from
+* @param b Signed fixed-decimal to subtract
+* @return Resulting subtracted signed fixed-decimal
+*/
+function sub(Fixed18 a, Fixed18 b) pure returns (Fixed18) {
+    return Fixed18.wrap(Fixed18.unwrap(a) - Fixed18.unwrap(b));
+}
+
+/**
+* @notice Multiplies two signed fixed-decimals `a` and `b` together
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Resulting multiplied signed fixed-decimal
+*/
+function mul(Fixed18 a, Fixed18 b) pure returns (Fixed18) {
+    return Fixed18.wrap(Fixed18.unwrap(a) * Fixed18.unwrap(b) / Fixed18Lib.BASE);
+}
+
+/**
+* @notice Divides signed fixed-decimal `a` by `b`
+* @param a Signed fixed-decimal to divide
+* @param b Signed fixed-decimal to divide by
+* @return Resulting divided signed fixed-decimal
+*/
+function div(Fixed18 a, Fixed18 b) pure returns (Fixed18) {
+    return Fixed18.wrap(Fixed18.unwrap(a) * Fixed18Lib.BASE / Fixed18.unwrap(b));
+}
+
+/**
+* @notice Returns whether signed fixed-decimal `a` is equal to `b`
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Whether `a` is equal to `b`
+*/
+function eq(Fixed18 a, Fixed18 b) pure returns (bool) {
+    return Fixed18.unwrap(a) == Fixed18.unwrap(b);
+}
+
+/**
+* @notice Returns whether signed fixed-decimal `a` is not equal to `b`
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Whether `a` is not equal to `b`
+*/
+function neq(Fixed18 a, Fixed18 b) pure returns (bool) {
+    return Fixed18.unwrap(a) != Fixed18.unwrap(b);
+}
+
+/**
+* @notice Returns whether signed fixed-decimal `a` is greater than `b`
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Whether `a` is greater than `b`
+*/
+function gt(Fixed18 a, Fixed18 b) pure returns (bool) {
+    (int256 au, int256 bu) = (Fixed18.unwrap(a), Fixed18.unwrap(b));
+    return au > bu;
+}
+
+/**
+* @notice Returns whether signed fixed-decimal `a` is less than `b`
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Whether `a` is less than `b`
+*/
+function lt(Fixed18 a, Fixed18 b) pure returns (bool) {
+    (int256 au, int256 bu) = (Fixed18.unwrap(a), Fixed18.unwrap(b));
+    return au < bu;
+}
+
+/**
+* @notice Returns whether signed fixed-decimal `a` is greater than or equal to `b`
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Whether `a` is greater than or equal to `b`
+*/
+function gte(Fixed18 a, Fixed18 b) pure returns (bool) {
+    return eq(a, b) || gt(a, b);
+}
+
+/**
+* @notice Returns whether signed fixed-decimal `a` is less than or equal to `b`
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Whether `a` is less than or equal to `b`
+*/
+function lte(Fixed18 a, Fixed18 b) pure returns (bool) {
+    return eq(a, b) || lt(a, b);
+}
diff --git a/src/number/types/Fixed6.sol b/src/number/types/Fixed6.sol
index bc812835..e36fbfdc 100644
--- a/src/number/types/Fixed6.sol
+++ b/src/number/types/Fixed6.sol
@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.13;
+pragma solidity ^0.8.19;
 
-import "@openzeppelin/contracts/utils/math/SignedMath.sol";
-import "../NumberMath.sol";
-import "./Fixed18.sol";
-import "./UFixed6.sol";
+import { SignedMath } from "@openzeppelin/contracts/utils/math/SignedMath.sol";
+import { NumberMath } from "../NumberMath.sol";
+import { Fixed18 } from "./Fixed18.sol";
+import { UFixed6 } from "./UFixed6.sol";
 
 /// @dev Fixed6 type
 type Fixed6 is int256;
@@ -12,6 +12,19 @@ using Fixed6Lib for Fixed6 global;
 type Fixed6Storage is bytes32;
 using Fixed6StorageLib for Fixed6Storage global;
 
+using {
+    add as +,
+    sub as -,
+    mul as *,
+    div as /,
+    eq as ==,
+    neq as !=,
+    gt as >,
+    lt as <,
+    gte as >=,
+    lte as <=
+} for Fixed6 global;
+
 /**
  * @title Fixed6Lib
  * @notice Library for the signed fixed-decimal type.
@@ -21,12 +34,12 @@ library Fixed6Lib {
     /// @custom:error Arithmetic overflow
     error Fixed6OverflowError(uint256 value);
 
-    int256 private constant BASE = 1e6;
-    Fixed6 public constant ZERO = Fixed6.wrap(0);
-    Fixed6 public constant ONE = Fixed6.wrap(BASE);
-    Fixed6 public constant NEG_ONE = Fixed6.wrap(-1 * BASE);
-    Fixed6 public constant MAX = Fixed6.wrap(type(int256).max);
-    Fixed6 public constant MIN = Fixed6.wrap(type(int256).min);
+    int256 internal constant BASE = 1e6;
+    Fixed6 internal constant ZERO = Fixed6.wrap(0);
+    Fixed6 internal constant ONE = Fixed6.wrap(BASE);
+    Fixed6 internal constant NEG_ONE = Fixed6.wrap(-1 * BASE);
+    Fixed6 internal constant MAX = Fixed6.wrap(type(int256).max);
+    Fixed6 internal constant MIN = Fixed6.wrap(type(int256).min);
 
     /**
      * @notice Creates a signed fixed-decimal from an unsigned fixed-decimal
@@ -92,8 +105,8 @@ library Fixed6Lib {
      */
     function from(Fixed6 significand, int256 exponent) internal pure returns (Fixed6) {
         return exponent < 0
-            ? significand.div(from(int256(10 ** uint256(-1 * exponent))))
-            : significand.mul(from(int256(10 ** uint256(exponent))));
+            ? significand / from(int256(10 ** uint256(-1 * exponent)))
+            : significand * from(int256(10 ** uint256(exponent)));
     }
 
     /**
@@ -105,36 +118,6 @@ library Fixed6Lib {
         return Fixed6.unwrap(a) == 0;
     }
 
-    /**
-     * @notice Adds two signed fixed-decimals `a` and `b` together
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Resulting summed signed fixed-decimal
-     */
-    function add(Fixed6 a, Fixed6 b) internal pure returns (Fixed6) {
-        return Fixed6.wrap(Fixed6.unwrap(a) + Fixed6.unwrap(b));
-    }
-
-    /**
-     * @notice Subtracts signed fixed-decimal `b` from `a`
-     * @param a Signed fixed-decimal to subtract from
-     * @param b Signed fixed-decimal to subtract
-     * @return Resulting subtracted signed fixed-decimal
-     */
-    function sub(Fixed6 a, Fixed6 b) internal pure returns (Fixed6) {
-        return Fixed6.wrap(Fixed6.unwrap(a) - Fixed6.unwrap(b));
-    }
-
-    /**
-     * @notice Multiplies two signed fixed-decimals `a` and `b` together
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Resulting multiplied signed fixed-decimal
-     */
-    function mul(Fixed6 a, Fixed6 b) internal pure returns (Fixed6) {
-        return Fixed6.wrap(Fixed6.unwrap(a) * Fixed6.unwrap(b) / BASE);
-    }
-
     /**
      * @notice Multiplies two signed fixed-decimals `a` and `b` together, rounding the result away from zero if there is a remainder
      * @param a First signed fixed-decimal
@@ -145,16 +128,6 @@ library Fixed6Lib {
         return Fixed6.wrap(NumberMath.divOut(Fixed6.unwrap(a) * Fixed6.unwrap(b), BASE));
     }
 
-    /**
-     * @notice Divides signed fixed-decimal `a` by `b`
-     * @param a Signed fixed-decimal to divide
-     * @param b Signed fixed-decimal to divide by
-     * @return Resulting divided signed fixed-decimal
-     */
-    function div(Fixed6 a, Fixed6 b) internal pure returns (Fixed6) {
-        return Fixed6.wrap(Fixed6.unwrap(a) * BASE / Fixed6.unwrap(b));
-    }
-
     /**
      * @notice Divides signed fixed-decimal `a` by `b`, rounding the result away from zero if there is a remainder
      * @param a Signed fixed-decimal to divide
@@ -243,56 +216,6 @@ library Fixed6Lib {
         return Fixed6.wrap(NumberMath.divOut(Fixed6.unwrap(a) * Fixed6.unwrap(b), Fixed6.unwrap(c)));
     }
 
-    /**
-     * @notice Returns whether signed fixed-decimal `a` is equal to `b`
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Whether `a` is equal to `b`
-     */
-    function eq(Fixed6 a, Fixed6 b) internal pure returns (bool) {
-        return compare(a, b) == 1;
-    }
-
-    /**
-     * @notice Returns whether signed fixed-decimal `a` is greater than `b`
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Whether `a` is greater than `b`
-     */
-    function gt(Fixed6 a, Fixed6 b) internal pure returns (bool) {
-        return compare(a, b) == 2;
-    }
-
-    /**
-     * @notice Returns whether signed fixed-decimal `a` is less than `b`
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Whether `a` is less than `b`
-     */
-    function lt(Fixed6 a, Fixed6 b) internal pure returns (bool) {
-        return compare(a, b) == 0;
-    }
-
-    /**
-     * @notice Returns whether signed fixed-decimal `a` is greater than or equal to `b`
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Whether `a` is greater than or equal to `b`
-     */
-    function gte(Fixed6 a, Fixed6 b) internal pure returns (bool) {
-        return gt(a, b) || eq(a, b);
-    }
-
-    /**
-     * @notice Returns whether signed fixed-decimal `a` is less than or equal to `b`
-     * @param a First signed fixed-decimal
-     * @param b Second signed fixed-decimal
-     * @return Whether `a` is less than or equal to `b`
-     */
-    function lte(Fixed6 a, Fixed6 b) internal pure returns (bool) {
-        return lt(a, b) || eq(a, b);
-    }
-
     /**
      * @notice Compares the signed fixed-decimals `a` and `b`
      * @dev Returns: 2 for greater than
@@ -407,3 +330,105 @@ library Fixed6StorageLib {
         }
     }
 }
+
+/**
+* @notice Adds two signed fixed-decimals `a` and `b` together
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Resulting summed signed fixed-decimal
+*/
+function add(Fixed6 a, Fixed6 b) pure returns (Fixed6) {
+    return Fixed6.wrap(Fixed6.unwrap(a) + Fixed6.unwrap(b));
+}
+
+/**
+* @notice Subtracts signed fixed-decimal `b` from `a`
+* @param a Signed fixed-decimal to subtract from
+* @param b Signed fixed-decimal to subtract
+* @return Resulting subtracted signed fixed-decimal
+*/
+function sub(Fixed6 a, Fixed6 b) pure returns (Fixed6) {
+    return Fixed6.wrap(Fixed6.unwrap(a) - Fixed6.unwrap(b));
+}
+
+/**
+* @notice Multiplies two signed fixed-decimals `a` and `b` together
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Resulting multiplied signed fixed-decimal
+*/
+function mul(Fixed6 a, Fixed6 b) pure returns (Fixed6) {
+    return Fixed6.wrap(Fixed6.unwrap(a) * Fixed6.unwrap(b) / Fixed6Lib.BASE);
+}
+
+/**
+* @notice Divides signed fixed-decimal `a` by `b`
+* @param a Signed fixed-decimal to divide
+* @param b Signed fixed-decimal to divide by
+* @return Resulting divided signed fixed-decimal
+*/
+function div(Fixed6 a, Fixed6 b) pure returns (Fixed6) {
+    return Fixed6.wrap(Fixed6.unwrap(a) * Fixed6Lib.BASE / Fixed6.unwrap(b));
+}
+
+/**
+* @notice Returns whether signed fixed-decimal `a` is equal to `b`
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Whether `a` is equal to `b`
+*/
+function eq(Fixed6 a, Fixed6 b) pure returns (bool) {
+    return Fixed6.unwrap(a) == Fixed6.unwrap(b);
+}
+
+/**
+* @notice Returns whether signed fixed-decimal `a` is not equal to `b`
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Whether `a` is not equal to `b`
+*/
+function neq(Fixed6 a, Fixed6 b) pure returns (bool) {
+    return Fixed6.unwrap(a) != Fixed6.unwrap(b);
+}
+
+/**
+* @notice Returns whether signed fixed-decimal `a` is greater than `b`
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Whether `a` is greater than `b`
+*/
+function gt(Fixed6 a, Fixed6 b) pure returns (bool) {
+    (int256 au, int256 bu) = (Fixed6.unwrap(a), Fixed6.unwrap(b));
+    return au > bu;
+}
+
+/**
+* @notice Returns whether signed fixed-decimal `a` is less than `b`
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Whether `a` is less than `b`
+*/
+function lt(Fixed6 a, Fixed6 b) pure returns (bool) {
+    (int256 au, int256 bu) = (Fixed6.unwrap(a), Fixed6.unwrap(b));
+    return au < bu;
+}
+
+/**
+* @notice Returns whether signed fixed-decimal `a` is greater than or equal to `b`
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Whether `a` is greater than or equal to `b`
+*/
+function gte(Fixed6 a, Fixed6 b) pure returns (bool) {
+    return eq(a, b) || gt(a, b);
+}
+
+/**
+* @notice Returns whether signed fixed-decimal `a` is less than or equal to `b`
+* @param a First signed fixed-decimal
+* @param b Second signed fixed-decimal
+* @return Whether `a` is less than or equal to `b`
+*/
+function lte(Fixed6 a, Fixed6 b) pure returns (bool) {
+    return eq(a, b) || lt(a, b);
+}
diff --git a/src/number/types/UFixed18.sol b/src/number/types/UFixed18.sol
index a7bd53b1..69a7c706 100644
--- a/src/number/types/UFixed18.sol
+++ b/src/number/types/UFixed18.sol
@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-import "@openzeppelin/contracts/utils/math/Math.sol";
-import "../NumberMath.sol";
-import "./Fixed18.sol";
-import "./UFixed6.sol";
+import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
+import { NumberMath } from "../NumberMath.sol";
+import { Fixed18, Fixed18Lib } from "./Fixed18.sol";
+import { UFixed6 } from "./UFixed6.sol";
 
 /// @dev UFixed18 type
 type UFixed18 is uint256;
@@ -12,6 +12,19 @@ using UFixed18Lib for UFixed18 global;
 type UFixed18Storage is bytes32;
 using UFixed18StorageLib for UFixed18Storage global;
 
+using {
+    add as +,
+    sub as -,
+    mul as *,
+    div as /,
+    eq as ==,
+    neq as !=,
+    gt as >,
+    lt as <,
+    gte as >=,
+    lte as <=
+} for UFixed18 global;
+
 /**
  * @title UFixed18Lib
  * @notice Library for the unsigned fixed-decimal type.
@@ -21,10 +34,10 @@ library UFixed18Lib {
     /// @custom:error Arithmetic underflow
     error UFixed18UnderflowError(int256 value);
 
-    uint256 private constant BASE = 1e18;
-    UFixed18 public constant ZERO = UFixed18.wrap(0);
-    UFixed18 public constant ONE = UFixed18.wrap(BASE);
-    UFixed18 public constant MAX = UFixed18.wrap(type(uint256).max);
+    uint256 internal constant BASE = 1e18;
+    UFixed18 internal constant ZERO = UFixed18.wrap(0);
+    UFixed18 internal constant ONE = UFixed18.wrap(BASE);
+    UFixed18 internal constant MAX = UFixed18.wrap(type(uint256).max);
 
     /**
      * @notice Creates a unsigned fixed-decimal from a signed fixed-decimal
@@ -44,7 +57,7 @@ library UFixed18Lib {
      * @return New unsigned fixed-decimal
      */
     function unsafeFrom(Fixed18 a) internal pure returns (UFixed18) {
-        return a.lt(Fixed18Lib.ZERO) ? ZERO : from(a);
+        return a < Fixed18Lib.ZERO ? ZERO : from(a);
     }
 
     /**
@@ -73,8 +86,8 @@ library UFixed18Lib {
      */
     function from(UFixed18 significand, int256 exponent) internal pure returns (UFixed18) {
         return exponent < 0
-            ? significand.div(from(10 ** uint256(-1 * exponent)))
-            : significand.mul(from(10 ** uint256(exponent)));
+            ? significand / from(10 ** uint256(-1 * exponent))
+            : significand * from(10 ** uint256(exponent));
     }
 
     /**
@@ -86,26 +99,6 @@ library UFixed18Lib {
         return UFixed18.unwrap(a) == 0;
     }
 
-    /**
-     * @notice Adds two unsigned fixed-decimals `a` and `b` together
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Resulting summed unsigned fixed-decimal
-     */
-    function add(UFixed18 a, UFixed18 b) internal pure returns (UFixed18) {
-        return UFixed18.wrap(UFixed18.unwrap(a) + UFixed18.unwrap(b));
-    }
-
-    /**
-     * @notice Subtracts unsigned fixed-decimal `b` from `a`
-     * @param a Unsigned fixed-decimal to subtract from
-     * @param b Unsigned fixed-decimal to subtract
-     * @return Resulting subtracted unsigned fixed-decimal
-     */
-    function sub(UFixed18 a, UFixed18 b) internal pure returns (UFixed18) {
-        return UFixed18.wrap(UFixed18.unwrap(a) - UFixed18.unwrap(b));
-    }
-
     /**
      * @notice Subtracts unsigned fixed-decimal `a` by `b`
      * @dev Does not revert on underflow, instead returns `ZERO`
@@ -117,16 +110,6 @@ library UFixed18Lib {
         return gt(b, a) ? ZERO : sub(a, b);
     }
 
-    /**
-     * @notice Multiplies two unsigned fixed-decimals `a` and `b` together
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Resulting multiplied unsigned fixed-decimal
-     */
-    function mul(UFixed18 a, UFixed18 b) internal pure returns (UFixed18) {
-        return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18.unwrap(b) / BASE);
-    }
-
     /**
      * @notice Multiplies two unsigned fixed-decimals `a` and `b` together, rounding the result up to the next integer if there is a remainder
      * @param a First unsigned fixed-decimal
@@ -137,16 +120,6 @@ library UFixed18Lib {
         return UFixed18.wrap(NumberMath.divOut(UFixed18.unwrap(a) * UFixed18.unwrap(b), BASE));
     }
 
-    /**
-     * @notice Divides unsigned fixed-decimal `a` by `b`
-     * @param a Unsigned fixed-decimal to divide
-     * @param b Unsigned fixed-decimal to divide by
-     * @return Resulting divided unsigned fixed-decimal
-     */
-    function div(UFixed18 a, UFixed18 b) internal pure returns (UFixed18) {
-        return UFixed18.wrap(UFixed18.unwrap(a) * BASE / UFixed18.unwrap(b));
-    }
-
     /**
      * @notice Divides unsigned fixed-decimal `a` by `b`, rounding the result up to the next integer if there is a remainder
      * @param a Unsigned fixed-decimal to divide
@@ -232,56 +205,6 @@ library UFixed18Lib {
         return UFixed18.wrap(NumberMath.divOut(UFixed18.unwrap(a) * UFixed18.unwrap(b), UFixed18.unwrap(c)));
     }
 
-    /**
-     * @notice Returns whether unsigned fixed-decimal `a` is equal to `b`
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Whether `a` is equal to `b`
-     */
-    function eq(UFixed18 a, UFixed18 b) internal pure returns (bool) {
-        return compare(a, b) == 1;
-    }
-
-    /**
-     * @notice Returns whether unsigned fixed-decimal `a` is greater than `b`
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Whether `a` is greater than `b`
-     */
-    function gt(UFixed18 a, UFixed18 b) internal pure returns (bool) {
-        return compare(a, b) == 2;
-    }
-
-    /**
-     * @notice Returns whether unsigned fixed-decimal `a` is less than `b`
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Whether `a` is less than `b`
-     */
-    function lt(UFixed18 a, UFixed18 b) internal pure returns (bool) {
-        return compare(a, b) == 0;
-    }
-
-    /**
-     * @notice Returns whether unsigned fixed-decimal `a` is greater than or equal to `b`
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Whether `a` is greater than or equal to `b`
-     */
-    function gte(UFixed18 a, UFixed18 b) internal pure returns (bool) {
-        return gt(a, b) || eq(a, b);
-    }
-
-    /**
-     * @notice Returns whether unsigned fixed-decimal `a` is less than or equal to `b`
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Whether `a` is less than or equal to `b`
-     */
-    function lte(UFixed18 a, UFixed18 b) internal pure returns (bool) {
-        return lt(a, b) || eq(a, b);
-    }
-
     /**
      * @notice Compares the unsigned fixed-decimals `a` and `b`
      * @dev Returns: 2 for greater than
@@ -373,3 +296,105 @@ library UFixed18StorageLib {
         }
     }
 }
+
+/**
+* @notice Adds two unsigned fixed-decimals `a` and `b` together
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Resulting summed unsigned fixed-decimal
+*/
+function add(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) + UFixed18.unwrap(b));
+}
+
+/**
+* @notice Subtracts unsigned fixed-decimal `b` from `a`
+* @param a Unsigned fixed-decimal to subtract from
+* @param b Unsigned fixed-decimal to subtract
+* @return Resulting subtracted unsigned fixed-decimal
+*/
+function sub(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) - UFixed18.unwrap(b));
+}
+
+/**
+* @notice Multiplies two unsigned fixed-decimals `a` and `b` together
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Resulting multiplied unsigned fixed-decimal
+*/
+function mul(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18.unwrap(b) / UFixed18Lib.BASE);
+}
+
+/**
+* @notice Divides unsigned fixed-decimal `a` by `b`
+* @param a Unsigned fixed-decimal to divide
+* @param b Unsigned fixed-decimal to divide by
+* @return Resulting divided unsigned fixed-decimal
+*/
+function div(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18Lib.BASE / UFixed18.unwrap(b));
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is equal to `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is equal to `b`
+*/
+function eq(UFixed18 a, UFixed18 b) pure returns (bool) {
+    return UFixed18.unwrap(a) == UFixed18.unwrap(b);
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is not equal to `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is not equal to `b`
+*/
+function neq(UFixed18 a, UFixed18 b)  pure returns (bool) {
+    return UFixed18.unwrap(a) != UFixed18.unwrap(b);
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is greater than `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is greater than `b`
+*/
+function gt(UFixed18 a, UFixed18 b) pure returns (bool) {
+    (uint256 au, uint256 bu) = (UFixed18.unwrap(a), UFixed18.unwrap(b));
+    return au > bu;
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is less than `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is less than `b`
+*/
+function lt(UFixed18 a, UFixed18 b) pure returns (bool) {
+    (uint256 au, uint256 bu) = (UFixed18.unwrap(a), UFixed18.unwrap(b));
+    return au < bu;
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is greater than or equal to `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is greater than or equal to `b`
+*/
+function gte(UFixed18 a, UFixed18 b) pure returns (bool) {
+    return eq(a, b) || gt(a, b);
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is less than or equal to `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is less than or equal to `b`
+*/
+function lte(UFixed18 a, UFixed18 b) pure returns (bool) {
+    return eq(a, b) || lt(a, b);
+}
diff --git a/src/number/types/UFixed6.sol b/src/number/types/UFixed6.sol
index c53a9a27..d9b8f6e4 100644
--- a/src/number/types/UFixed6.sol
+++ b/src/number/types/UFixed6.sol
@@ -1,10 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.13;
+pragma solidity ^0.8.19;
 
-import "@openzeppelin/contracts/utils/math/Math.sol";
-import "../NumberMath.sol";
-import "./Fixed6.sol";
-import "./UFixed18.sol";
+import { Math, NumberMath } from "../NumberMath.sol";
+import { Fixed6, Fixed6Lib } from "./Fixed6.sol";
+import { UFixed18 } from "./UFixed18.sol";
 
 /// @dev UFixed6 type
 type UFixed6 is uint256;
@@ -12,6 +11,19 @@ using UFixed6Lib for UFixed6 global;
 type UFixed6Storage is bytes32;
 using UFixed6StorageLib for UFixed6Storage global;
 
+using {
+    add as +,
+    sub as -,
+    mul as *,
+    div as /,
+    eq as ==,
+    neq as !=,
+    gt as >,
+    lt as <,
+    gte as >=,
+    lte as <=
+} for UFixed6 global;
+
 /**
  * @title UFixed6Lib
  * @notice Library for the unsigned fixed-decimal type.
@@ -21,10 +33,10 @@ library UFixed6Lib {
     /// @custom:error Arithmetic underflow
     error UFixed6UnderflowError(int256 value);
 
-    uint256 private constant BASE = 1e6;
-    UFixed6 public constant ZERO = UFixed6.wrap(0);
-    UFixed6 public constant ONE = UFixed6.wrap(BASE);
-    UFixed6 public constant MAX = UFixed6.wrap(type(uint256).max);
+    uint256 internal constant BASE = 1e6;
+    UFixed6 internal constant ZERO = UFixed6.wrap(0);
+    UFixed6 internal constant ONE = UFixed6.wrap(BASE);
+    UFixed6 internal constant MAX = UFixed6.wrap(type(uint256).max);
 
     /**
      * @notice Creates a unsigned fixed-decimal from a signed fixed-decimal
@@ -44,7 +56,7 @@ library UFixed6Lib {
      * @return New unsigned fixed-decimal
      */
     function unsafeFrom(Fixed6 a) internal pure returns (UFixed6) {
-        return a.lt(Fixed6Lib.ZERO) ? ZERO : from(a);
+        return a < Fixed6Lib.ZERO ? ZERO : from(a);
     }
 
     /**
@@ -83,224 +95,133 @@ library UFixed6Lib {
      */
     function from(UFixed6 significand, int256 exponent) internal pure returns (UFixed6) {
         return exponent < 0
-            ? significand.div(from(10 ** uint256(-1 * exponent)))
-            : significand.mul(from(10 ** uint256(exponent)));
+            ? significand / from(10 ** uint256(-1 * exponent))
+            : significand * from(10 ** uint256(exponent));
     }
 
     /**
-     * @notice Returns whether the unsigned fixed-decimal is equal to zero.
-     * @param a Unsigned fixed-decimal
-     * @return Whether the unsigned fixed-decimal is zero.
-     */
+    * @notice Returns whether the unsigned fixed-decimal is equal to zero.
+    * @param a Unsigned fixed-decimal
+    * @return Whether the unsigned fixed-decimal is zero.
+    */
     function isZero(UFixed6 a) internal pure returns (bool) {
         return UFixed6.unwrap(a) == 0;
     }
 
     /**
-     * @notice Adds two unsigned fixed-decimals `a` and `b` together
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Resulting summed unsigned fixed-decimal
-     */
-    function add(UFixed6 a, UFixed6 b) internal pure returns (UFixed6) {
-        return UFixed6.wrap(UFixed6.unwrap(a) + UFixed6.unwrap(b));
-    }
-
-    /**
-     * @notice Subtracts unsigned fixed-decimal `b` from `a`
-     * @param a Unsigned fixed-decimal to subtract from
-     * @param b Unsigned fixed-decimal to subtract
-     * @return Resulting subtracted unsigned fixed-decimal
-     */
-    function sub(UFixed6 a, UFixed6 b) internal pure returns (UFixed6) {
-        return UFixed6.wrap(UFixed6.unwrap(a) - UFixed6.unwrap(b));
-    }
-
-    /**
-     * @notice Subtracts unsigned fixed-decimal `a` by `b`
-     * @dev Does not revert on underflow, instead returns `ZERO`
-     * @param a Unsigned fixed-decimal to subtract from
-     * @param b Unsigned fixed-decimal to subtract
-     * @return Resulting subtracted unsigned fixed-decimal
-     */
+    * @notice Subtracts unsigned fixed-decimal `a` by `b`
+    * @dev Does not revert on underflow, instead returns `ZERO`
+    * @param a Unsigned fixed-decimal to subtract from
+    * @param b Unsigned fixed-decimal to subtract
+    * @return Resulting subtracted unsigned fixed-decimal
+    */
     function unsafeSub(UFixed6 a, UFixed6 b) internal pure returns (UFixed6) {
-        return gt(b, a) ? ZERO : sub(a, b);
-    }
-
-    /**
-     * @notice Multiplies two unsigned fixed-decimals `a` and `b` together
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Resulting multiplied unsigned fixed-decimal
-     */
-    function mul(UFixed6 a, UFixed6 b) internal pure returns (UFixed6) {
-        return UFixed6.wrap(UFixed6.unwrap(a) * UFixed6.unwrap(b) / BASE);
+        return gt(b, a) ? UFixed6Lib.ZERO : sub(a, b);
     }
 
     /**
-     * @notice Multiplies two unsigned fixed-decimals `a` and `b` together, rounding the result up to the next integer if there is a remainder
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Resulting multiplied unsigned fixed-decimal
-     */
+    * @notice Multiplies two unsigned fixed-decimals `a` and `b` together, rounding the result up to the next integer if there is a remainder
+    * @param a First unsigned fixed-decimal
+    * @param b Second unsigned fixed-decimal
+    * @return Resulting multiplied unsigned fixed-decimal
+    */
     function mulOut(UFixed6 a, UFixed6 b) internal pure returns (UFixed6) {
-        return UFixed6.wrap(NumberMath.divOut(UFixed6.unwrap(a) * UFixed6.unwrap(b), BASE));
+        return UFixed6.wrap(NumberMath.divOut(UFixed6.unwrap(a) * UFixed6.unwrap(b), UFixed6Lib.BASE));
     }
 
     /**
-     * @notice Divides unsigned fixed-decimal `a` by `b`
-     * @param a Unsigned fixed-decimal to divide
-     * @param b Unsigned fixed-decimal to divide by
-     * @return Resulting divided unsigned fixed-decimal
-     */
-    function div(UFixed6 a, UFixed6 b) internal pure returns (UFixed6) {
-        return UFixed6.wrap(UFixed6.unwrap(a) * BASE / UFixed6.unwrap(b));
-    }
-
-    /**
-     * @notice Divides unsigned fixed-decimal `a` by `b`, rounding the result up to the next integer if there is a remainder
-     * @param a Unsigned fixed-decimal to divide
-     * @param b Unsigned fixed-decimal to divide by
-     * @return Resulting divided unsigned fixed-decimal
-     */
+    * @notice Divides unsigned fixed-decimal `a` by `b`, rounding the result up to the next integer if there is a remainder
+    * @param a Unsigned fixed-decimal to divide
+    * @param b Unsigned fixed-decimal to divide by
+    * @return Resulting divided unsigned fixed-decimal
+    */
     function divOut(UFixed6 a, UFixed6 b) internal pure returns (UFixed6) {
-        return UFixed6.wrap(NumberMath.divOut(UFixed6.unwrap(a) * BASE, UFixed6.unwrap(b)));
+        return UFixed6.wrap(NumberMath.divOut(UFixed6.unwrap(a) * UFixed6Lib.BASE, UFixed6.unwrap(b)));
     }
 
     /**
-     * @notice Divides unsigned fixed-decimal `a` by `b`
-     * @dev Does not revert on divide-by-0, instead returns `ONE` for `0/0` and `MAX` for `n/0`.
-     * @param a Unsigned fixed-decimal to divide
-     * @param b Unsigned fixed-decimal to divide by
-     * @return Resulting divided unsigned fixed-decimal
-     */
+    * @notice Divides unsigned fixed-decimal `a` by `b`
+    * @dev Does not revert on divide-by-0, instead returns `ONE` for `0/0` and `MAX` for `n/0`.
+    * @param a Unsigned fixed-decimal to divide
+    * @param b Unsigned fixed-decimal to divide by
+    * @return Resulting divided unsigned fixed-decimal
+    */
     function unsafeDiv(UFixed6 a, UFixed6 b) internal pure returns (UFixed6) {
         if (isZero(b)) {
-            return isZero(a) ? ONE : MAX;
+            return isZero(a) ? UFixed6Lib.ONE : UFixed6Lib.MAX;
         } else {
             return div(a, b);
         }
     }
 
     /**
-     * @notice Divides unsigned fixed-decimal `a` by `b`, rounding the result up to the next integer if there is a remainder
-     * @dev Does not revert on divide-by-0, instead returns `ONE` for `0/0` and `MAX` for `n/0`.
-     * @param a Unsigned fixed-decimal to divide
-     * @param b Unsigned fixed-decimal to divide by
-     * @return Resulting divided unsigned fixed-decimal
-     */
+    * @notice Divides unsigned fixed-decimal `a` by `b`, rounding the result up to the next integer if there is a remainder
+    * @dev Does not revert on divide-by-0, instead returns `ONE` for `0/0` and `MAX` for `n/0`.
+    * @param a Unsigned fixed-decimal to divide
+    * @param b Unsigned fixed-decimal to divide by
+    * @return Resulting divided unsigned fixed-decimal
+    */
     function unsafeDivOut(UFixed6 a, UFixed6 b) internal pure returns (UFixed6) {
         if (isZero(b)) {
-            return isZero(a) ? ONE : MAX;
+            return isZero(a) ? UFixed6Lib.ONE : UFixed6Lib.MAX;
         } else {
             return divOut(a, b);
         }
     }
 
     /**
-     * @notice Computes a * b / c without loss of precision due to BASE conversion
-     * @param a First unsigned fixed-decimal
-     * @param b Unsigned number to multiply by
-     * @param c Unsigned number to divide by
-     * @return Resulting computation
-     */
+    * @notice Computes a * b / c without loss of precision due to BASE conversion
+    * @param a First unsigned fixed-decimal
+    * @param b Unsigned number to multiply by
+    * @param c Unsigned number to divide by
+    * @return Resulting computation
+    */
     function muldiv(UFixed6 a, uint256 b, uint256 c) internal pure returns (UFixed6) {
-        return muldiv(a, UFixed6.wrap(b), UFixed6.wrap(c));
+        return muldivFixed(a, UFixed6.wrap(b), UFixed6.wrap(c));
     }
 
     /**
-     * @notice Computes a * b / c without loss of precision due to BASE conversion, rounding the result up to the next integer if there is a remainder
-     * @param a First unsigned fixed-decimal
-     * @param b Unsigned number to multiply by
-     * @param c Unsigned number to divide by
-     * @return Resulting computation
-     */
+    * @notice Computes a * b / c without loss of precision due to BASE conversion, rounding the result up to the next integer if there is a remainder
+    * @param a First unsigned fixed-decimal
+    * @param b Unsigned number to multiply by
+    * @param c Unsigned number to divide by
+    * @return Resulting computation
+    */
     function muldivOut(UFixed6 a, uint256 b, uint256 c) internal pure returns (UFixed6) {
-        return muldivOut(a, UFixed6.wrap(b), UFixed6.wrap(c));
+        return muldivOutFixed(a, UFixed6.wrap(b), UFixed6.wrap(c));
     }
 
-
     /**
-     * @notice Computes a * b / c without loss of precision due to BASE conversion
-     * @param a First unsigned fixed-decimal
-     * @param b Unsigned fixed-decimal to multiply by
-     * @param c Unsigned fixed-decimal to divide by
-     * @return Resulting computation
-     */
-    function muldiv(UFixed6 a, UFixed6 b, UFixed6 c) internal pure returns (UFixed6) {
+    * @notice Computes a * b / c without loss of precision due to BASE conversion
+    * @param a First unsigned fixed-decimal
+    * @param b Unsigned fixed-decimal to multiply by
+    * @param c Unsigned fixed-decimal to divide by
+    * @return Resulting computation
+    */
+    function muldivFixed(UFixed6 a, UFixed6 b, UFixed6 c) internal pure returns (UFixed6) {
         return UFixed6.wrap(UFixed6.unwrap(a) * UFixed6.unwrap(b) / UFixed6.unwrap(c));
     }
 
     /**
-     * @notice Computes a * b / c without loss of precision due to BASE conversion, rounding the result up to the next integer if there is a remainder
-     * @param a First unsigned fixed-decimal
-     * @param b Unsigned fixed-decimal to multiply by
-     * @param c Unsigned fixed-decimal to divide by
-     * @return Resulting computation
-     */
-    function muldivOut(UFixed6 a, UFixed6 b, UFixed6 c) internal pure returns (UFixed6) {
+    * @notice Computes a * b / c without loss of precision due to BASE conversion, rounding the result up to the next integer if there is a remainder
+    * @param a First unsigned fixed-decimal
+    * @param b Unsigned fixed-decimal to multiply by
+    * @param c Unsigned fixed-decimal to divide by
+    * @return Resulting computation
+    */
+    function muldivOutFixed(UFixed6 a, UFixed6 b, UFixed6 c) internal pure returns (UFixed6) {
         return UFixed6.wrap(NumberMath.divOut(UFixed6.unwrap(a) * UFixed6.unwrap(b), UFixed6.unwrap(c)));
     }
 
     /**
-     * @notice Returns whether unsigned fixed-decimal `a` is equal to `b`
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Whether `a` is equal to `b`
-     */
-    function eq(UFixed6 a, UFixed6 b) internal pure returns (bool) {
-        return compare(a, b) == 1;
-    }
-
-    /**
-     * @notice Returns whether unsigned fixed-decimal `a` is greater than `b`
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Whether `a` is greater than `b`
-     */
-    function gt(UFixed6 a, UFixed6 b) internal pure returns (bool) {
-        return compare(a, b) == 2;
-    }
-
-    /**
-     * @notice Returns whether unsigned fixed-decimal `a` is less than `b`
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Whether `a` is less than `b`
-     */
-    function lt(UFixed6 a, UFixed6 b) internal pure returns (bool) {
-        return compare(a, b) == 0;
-    }
-
-    /**
-     * @notice Returns whether unsigned fixed-decimal `a` is greater than or equal to `b`
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Whether `a` is greater than or equal to `b`
-     */
-    function gte(UFixed6 a, UFixed6 b) internal pure returns (bool) {
-        return gt(a, b) || eq(a, b);
-    }
-
-    /**
-     * @notice Returns whether unsigned fixed-decimal `a` is less than or equal to `b`
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Whether `a` is less than or equal to `b`
-     */
-    function lte(UFixed6 a, UFixed6 b) internal pure returns (bool) {
-        return lt(a, b) || eq(a, b);
-    }
-
-    /**
-     * @notice Compares the unsigned fixed-decimals `a` and `b`
-     * @dev Returns: 2 for greater than
-     *               1 for equal to
-     *               0 for less than
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Compare result of `a` and `b`
-     */
+    * @notice Compares the unsigned fixed-decimals `a` and `b`
+    * @dev Returns: 2 for greater than
+    *               1 for equal to
+    *               0 for less than
+    * @param a First unsigned fixed-decimal
+    * @param b Second unsigned fixed-decimal
+    * @return Compare result of `a` and `b`
+    */
     function compare(UFixed6 a, UFixed6 b) internal pure returns (uint256) {
         (uint256 au, uint256 bu) = (UFixed6.unwrap(a), UFixed6.unwrap(b));
         if (au > bu) return 2;
@@ -309,62 +230,62 @@ library UFixed6Lib {
     }
 
     /**
-     * @notice Returns a unsigned fixed-decimal representing the ratio of `a` over `b`
-     * @param a First unsigned number
-     * @param b Second unsigned number
-     * @return Ratio of `a` over `b`
-     */
+    * @notice Returns a unsigned fixed-decimal representing the ratio of `a` over `b`
+    * @param a First unsigned number
+    * @param b Second unsigned number
+    * @return Ratio of `a` over `b`
+    */
     function ratio(uint256 a, uint256 b) internal pure returns (UFixed6) {
-        return UFixed6.wrap(a * BASE / b);
+        return UFixed6.wrap(a * UFixed6Lib.BASE / b);
     }
 
     /**
-     * @notice Returns the minimum of unsigned fixed-decimals `a` and `b`
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Minimum of `a` and `b`
-     */
+    * @notice Returns the minimum of unsigned fixed-decimals `a` and `b`
+    * @param a First unsigned fixed-decimal
+    * @param b Second unsigned fixed-decimal
+    * @return Minimum of `a` and `b`
+    */
     function min(UFixed6 a, UFixed6 b) internal pure returns (UFixed6) {
         return UFixed6.wrap(Math.min(UFixed6.unwrap(a), UFixed6.unwrap(b)));
     }
 
     /**
-     * @notice Returns the maximum of unsigned fixed-decimals `a` and `b`
-     * @param a First unsigned fixed-decimal
-     * @param b Second unsigned fixed-decimal
-     * @return Maximum of `a` and `b`
-     */
+    * @notice Returns the maximum of unsigned fixed-decimals `a` and `b`
+    * @param a First unsigned fixed-decimal
+    * @param b Second unsigned fixed-decimal
+    * @return Maximum of `a` and `b`
+    */
     function max(UFixed6 a, UFixed6 b) internal pure returns (UFixed6) {
         return UFixed6.wrap(Math.max(UFixed6.unwrap(a), UFixed6.unwrap(b)));
     }
 
     /**
-     * @notice Converts the unsigned fixed-decimal into an integer, truncating any decimal portion
-     * @param a Unsigned fixed-decimal
-     * @return Truncated unsigned number
-     */
+    * @notice Converts the unsigned fixed-decimal into an integer, truncating any decimal portion
+    * @param a Unsigned fixed-decimal
+    * @return Truncated unsigned number
+    */
     function truncate(UFixed6 a) internal pure returns (uint256) {
-        return UFixed6.unwrap(a) / BASE;
+        return UFixed6.unwrap(a) / UFixed6Lib.BASE;
     }
 
     /**
-     * @notice Returns whether the unsigned fixed-decimal `value` is inside the range `min` and `max`
-     * @param value Unsigned fixed-decimal to check
-     * @param min_ Minimum value
-     * @param max_ Maximum value
-     * @return Whether `value` is inside the range `min` and `max`
-     */
+    * @notice Returns whether the unsigned fixed-decimal `value` is inside the range `min` and `max`
+    * @param value Unsigned fixed-decimal to check
+    * @param min_ Minimum value
+    * @param max_ Maximum value
+    * @return Whether `value` is inside the range `min` and `max`
+    */
     function inside(UFixed6 value, UFixed6 min_, UFixed6 max_) internal pure returns (bool) {
         return !outside(value, min_, max_);
     }
 
     /**
-     * @notice Returns whether the unsigned fixed-decimal `value` is outside the range `min` and `max`
-     * @param value Unsigned fixed-decimal to check
-     * @param min_ Minimum value
-     * @param max_ Maximum value
-     * @return Whether `value` is outside the range `min` and `max`
-     */
+    * @notice Returns whether the unsigned fixed-decimal `value` is outside the range `min` and `max`
+    * @param value Unsigned fixed-decimal to check
+    * @param min_ Minimum value
+    * @param max_ Maximum value
+    * @return Whether `value` is outside the range `min` and `max`
+    */
     function outside(UFixed6 value, UFixed6 min_, UFixed6 max_) internal pure returns (bool) {
         return lt(value, min_) || gt(value, max_);
     }
@@ -383,3 +304,105 @@ library UFixed6StorageLib {
         }
     }
 }
+
+/**
+* @notice Adds two unsigned fixed-decimals `a` and `b` together
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Resulting summed unsigned fixed-decimal
+*/
+function add(UFixed6 a, UFixed6 b) pure returns (UFixed6) {
+    return UFixed6.wrap(UFixed6.unwrap(a) + UFixed6.unwrap(b));
+}
+
+/**
+* @notice Subtracts unsigned fixed-decimal `b` from `a`
+* @param a Unsigned fixed-decimal to subtract from
+* @param b Unsigned fixed-decimal to subtract
+* @return Resulting subtracted unsigned fixed-decimal
+*/
+function sub(UFixed6 a, UFixed6 b) pure returns (UFixed6) {
+    return UFixed6.wrap(UFixed6.unwrap(a) - UFixed6.unwrap(b));
+}
+
+/**
+* @notice Multiplies two unsigned fixed-decimals `a` and `b` together
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Resulting multiplied unsigned fixed-decimal
+*/
+function mul(UFixed6 a, UFixed6 b) pure returns (UFixed6) {
+    return UFixed6.wrap(UFixed6.unwrap(a) * UFixed6.unwrap(b) / UFixed6Lib.BASE);
+}
+
+/**
+* @notice Divides unsigned fixed-decimal `a` by `b`
+* @param a Unsigned fixed-decimal to divide
+* @param b Unsigned fixed-decimal to divide by
+* @return Resulting divided unsigned fixed-decimal
+*/
+function div(UFixed6 a, UFixed6 b) pure returns (UFixed6) {
+    return UFixed6.wrap(UFixed6.unwrap(a) * UFixed6Lib.BASE / UFixed6.unwrap(b));
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is equal to `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is equal to `b`
+*/
+function eq(UFixed6 a, UFixed6 b) pure returns (bool) {
+    return UFixed6.unwrap(a) == UFixed6.unwrap(b);
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is not equal to `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is not equal to `b`
+*/
+function neq(UFixed6 a, UFixed6 b) pure returns (bool) {
+    return UFixed6.unwrap(a) != UFixed6.unwrap(b);
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is greater than `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is greater than `b`
+*/
+function gt(UFixed6 a, UFixed6 b) pure returns (bool) {
+    (uint256 au, uint256 bu) = (UFixed6.unwrap(a), UFixed6.unwrap(b));
+    return au > bu;
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is less than `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is less than `b`
+*/
+function lt(UFixed6 a, UFixed6 b) pure returns (bool) {
+    (uint256 au, uint256 bu) = (UFixed6.unwrap(a), UFixed6.unwrap(b));
+    return au < bu;
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is greater than or equal to `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is greater than or equal to `b`
+*/
+function gte(UFixed6 a, UFixed6 b) pure returns (bool) {
+    return eq(a, b) || gt(a, b);
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is less than or equal to `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is less than or equal to `b`
+*/
+function lte(UFixed6 a, UFixed6 b) pure returns (bool) {
+    return eq(a, b) || lt(a, b);
+}
diff --git a/src/synbook/types/SynBook6.sol b/src/synbook/types/SynBook6.sol
index ae4dc306..ad8f2a13 100644
--- a/src/synbook/types/SynBook6.sol
+++ b/src/synbook/types/SynBook6.sol
@@ -33,17 +33,17 @@ library SynBook6Lib {
         UFixed6 price
     ) internal pure returns (Fixed6) {
         // sign = 1 for buy / ask and -1 for sell / bid, use f(-x) for sell orders
-        if (change.lt(Fixed6Lib.ZERO)) {
-            latest = latest.mul(Fixed6Lib.NEG_ONE);
-            change = change.mul(Fixed6Lib.NEG_ONE);
+        if (change < Fixed6Lib.ZERO) {
+            latest = latest * Fixed6Lib.NEG_ONE;
+            change = change * Fixed6Lib.NEG_ONE;
         }
 
-        Fixed6 from = latest.div(Fixed6Lib.from(self.scale));
-        Fixed6 to = latest.add(change).div(Fixed6Lib.from(self.scale));
-        UFixed6 notional = change.abs().mul(price);
+        Fixed6 from = latest / Fixed6Lib.from(self.scale);
+        Fixed6 to = (latest + change) / Fixed6Lib.from(self.scale);
+        UFixed6 notional = change.abs() * price;
 
         return _indefinite(self.d0, self.d1, self.d2, self.d3, to, notional)
-            .sub(_indefinite(self.d0, self.d1, self.d2, self.d3, from, notional));
+            - _indefinite(self.d0, self.d1, self.d2, self.d3, from, notional);
     }
 
     /// @dev f(x) = d0 * x + d1 * x^2 / 2 + d2 * x^3 / 3 + d3 * x^4 / 4
@@ -56,15 +56,15 @@ library SynBook6Lib {
         UFixed6 notional
     ) private pure returns (Fixed6 result) {
         // d0 * x
-        result = Fixed6Lib.from(notional).mul(value).mul(Fixed6Lib.from(d0));
+        result = Fixed6Lib.from(notional) * value * Fixed6Lib.from(d0);
 
         // d1 * x^2 / 2
-        result = result.add(Fixed6Lib.from(notional).mul(value).mul(value).mul(Fixed6Lib.from(d1)).div(Fixed6Lib.from(2)));
+        result = result + (Fixed6Lib.from(notional) * value * value * Fixed6Lib.from(d1) / Fixed6Lib.from(2));
 
         // d2 * x^3 / 3
-        result = result.add(Fixed6Lib.from(notional).mul(value).mul(value).mul(value).mul(Fixed6Lib.from(d2)).div(Fixed6Lib.from(3)));
+        result = result + (Fixed6Lib.from(notional) * value * value * value *  Fixed6Lib.from(d2) / Fixed6Lib.from(3));
 
         // d3 * x^4 / 4
-        result = result.add(Fixed6Lib.from(notional).mul(value).mul(value).mul(value).mul(value).mul(Fixed6Lib.from(d3)).div(Fixed6Lib.from(4)));
+        result = result + (Fixed6Lib.from(notional) * value * value * value * value * Fixed6Lib.from(d3) / Fixed6Lib.from(4));
     }
 }
diff --git a/src/token/types/Token18.sol b/src/token/types/Token18.sol
index 0e52822d..a9855d1b 100644
--- a/src/token/types/Token18.sol
+++ b/src/token/types/Token18.sol
@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "../../number/types/UFixed18.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { UFixed18 } from "../../number/types/UFixed18.sol";
 
 /// @dev Token18
 type Token18 is address;
@@ -38,7 +38,7 @@ library Token18Lib {
      * @return Whether the two tokens are equal
      */
     function eq(Token18 a, Token18 b) internal pure returns (bool) {
-        return Token18.unwrap(a) ==  Token18.unwrap(b);
+        return Token18.unwrap(a) == Token18.unwrap(b);
     }
 
     /**
diff --git a/src/token/types/Token6.sol b/src/token/types/Token6.sol
index 61056cf3..bde6b7c9 100644
--- a/src/token/types/Token6.sol
+++ b/src/token/types/Token6.sol
@@ -1,11 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "@openzeppelin/contracts/utils/math/Math.sol";
-import "../../number/types/UFixed6.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { UFixed6 } from "../../number/types/UFixed6.sol";
 
 /// @dev Token6
 type Token6 is address;
diff --git a/src/utilization/CurveMath18.sol b/src/utilization/CurveMath18.sol
index 0f917909..c0227424 100644
--- a/src/utilization/CurveMath18.sol
+++ b/src/utilization/CurveMath18.sol
@@ -29,12 +29,12 @@ library CurveMath18 {
         Fixed18 endY,
         UFixed18 targetX
     ) internal pure returns (Fixed18) {
-        if (targetX.lt(startX) || targetX.gt(endX)) revert CurveMath18OutOfBoundsError();
+        if (targetX < startX || targetX > endX) revert CurveMath18OutOfBoundsError();
 
-        UFixed18 xRange = endX.sub(startX);
-        Fixed18 yRange = endY.sub(startY);
-        UFixed18 xRatio = targetX.sub(startX).div(xRange);
-        return yRange.mul(Fixed18Lib.from(xRatio)).add(startY);
+        UFixed18 xRange = endX - startX;
+        Fixed18 yRange = endY - startY;
+        UFixed18 xRatio = (targetX - startX) / xRange;
+        return yRange * Fixed18Lib.from(xRatio) + startY;
     }
 
     /**
diff --git a/src/utilization/CurveMath6.sol b/src/utilization/CurveMath6.sol
index 15716f0c..182a89c0 100644
--- a/src/utilization/CurveMath6.sol
+++ b/src/utilization/CurveMath6.sol
@@ -29,12 +29,12 @@ library CurveMath6 {
         Fixed6 endY,
         UFixed6 targetX
     ) internal pure returns (Fixed6) {
-        if (targetX.lt(startX) || targetX.gt(endX)) revert CurveMath6OutOfBoundsError();
+        if (targetX < startX || targetX > endX) revert CurveMath6OutOfBoundsError();
 
-        UFixed6 xRange = endX.sub(startX);
-        Fixed6 yRange = endY.sub(startY);
-        UFixed6 xRatio = targetX.sub(startX).div(xRange);
-        return yRange.mul(Fixed6Lib.from(xRatio)).add(startY);
+        UFixed6 xRange = endX - startX;
+        Fixed6 yRange = endY - startY;
+        UFixed6 xRatio = (targetX - startX) / xRange;
+        return yRange * Fixed6Lib.from(xRatio) + startY;
     }
 
     /**
diff --git a/src/utilization/types/JumpRateUtilizationCurve18.sol b/src/utilization/types/JumpRateUtilizationCurve18.sol
index 487ca30b..daee9505 100644
--- a/src/utilization/types/JumpRateUtilizationCurve18.sol
+++ b/src/utilization/types/JumpRateUtilizationCurve18.sol
@@ -25,7 +25,7 @@ library JumpRateUtilizationCurve18Lib {
      * @return The corresponding rate
      */
     function compute(JumpRateUtilizationCurve18 memory self, UFixed18 utilization) internal pure returns (UFixed18) {
-        if (utilization.lt(self.targetUtilization)) {
+        if (utilization < self.targetUtilization) {
             return CurveMath18.linearInterpolation(
                 UFixed18Lib.ZERO,
                 self.minRate,
@@ -34,7 +34,7 @@ library JumpRateUtilizationCurve18Lib {
                 utilization
             );
         }
-        if (utilization.lt(UFixed18Lib.ONE)) {
+        if (utilization< UFixed18Lib.ONE) {
             return CurveMath18.linearInterpolation(
                 self.targetUtilization,
                 self.targetRate,
@@ -54,8 +54,8 @@ library JumpRateUtilizationCurve18Lib {
         UFixed18 notional
     ) internal pure returns (UFixed18) {
         return compute(self, utilization)
-            .mul(UFixed18Lib.from(toTimestamp - fromTimestamp))
-            .mul(notional)
-            .div(UFixed18Lib.from(365 days));
+            * UFixed18Lib.from(toTimestamp - fromTimestamp)
+            * notional
+            / UFixed18Lib.from(365 days);
     }
 }
diff --git a/src/utilization/types/JumpRateUtilizationCurve6.sol b/src/utilization/types/JumpRateUtilizationCurve6.sol
index a9de98d2..75e36a75 100644
--- a/src/utilization/types/JumpRateUtilizationCurve6.sol
+++ b/src/utilization/types/JumpRateUtilizationCurve6.sol
@@ -24,7 +24,7 @@ library JumpRateUtilizationCurve6Lib {
      * @return The corresponding rate
      */
     function compute(JumpRateUtilizationCurve6 memory self, UFixed6 utilization) internal pure returns (UFixed6) {
-        if (utilization.lt(self.targetUtilization)) {
+        if (utilization < self.targetUtilization) {
             return CurveMath6.linearInterpolation(
                 UFixed6Lib.ZERO,
                 self.minRate,
@@ -33,7 +33,7 @@ library JumpRateUtilizationCurve6Lib {
                 utilization
             );
         }
-        if (utilization.lt(UFixed6Lib.ONE)) {
+        if (utilization < UFixed6Lib.ONE) {
             return CurveMath6.linearInterpolation(
                 self.targetUtilization,
                 self.targetRate,
@@ -53,8 +53,8 @@ library JumpRateUtilizationCurve6Lib {
         UFixed6 notional
     ) internal pure returns (UFixed6) {
         return compute(self, utilization)
-            .mul(UFixed6Lib.from(toTimestamp - fromTimestamp))
-            .mul(notional)
-            .div(UFixed6Lib.from(365 days));
+            * UFixed6Lib.from(toTimestamp - fromTimestamp)
+            * notional
+            / UFixed6Lib.from(365 days);
     }
 }
diff --git a/test/number/Fixed18.t.sol b/test/number/Fixed18.t.sol
index 0a0d863a..e629c76d 100644
--- a/test/number/Fixed18.t.sol
+++ b/test/number/Fixed18.t.sol
@@ -118,45 +118,45 @@ contract Fixed18Test is Test {
     function test_addition() public pure {
         Fixed18 a = Fixed18Lib.from(10);
         Fixed18 b = Fixed18Lib.from(20);
-        assertEq(Fixed18.unwrap(Fixed18Lib.add(a, b)), 30e18, "10 + 20 = 30");
+        assertEq(Fixed18.unwrap(a + b), 30e18, "10 + 20 = 30");
 
         a = Fixed18Lib.from(-10);
         b = Fixed18Lib.from(-20);
-        assertEq(Fixed18.unwrap(Fixed18Lib.add(a, b)), -30e18, "-10 + -20 = -30");
+        assertEq(Fixed18.unwrap(a + b), -30e18, "-10 + -20 = -30");
     }
 
     function test_subtraction() public pure {
         Fixed18 a = Fixed18Lib.from(20);
         Fixed18 b = Fixed18Lib.from(10);
-        assertEq(Fixed18.unwrap(Fixed18Lib.sub(a, b)), 10e18, "20 - 10 = 10");
+        assertEq(Fixed18.unwrap(a - b), 10e18, "20 - 10 = 10");
 
         a = Fixed18Lib.from(-20);
         b = Fixed18Lib.from(-10);
-        assertEq(Fixed18.unwrap(Fixed18Lib.sub(a, b)), -10e18, "-20 - -10 = -10");
+        assertEq(Fixed18.unwrap(a - b), -10e18, "-20 - -10 = -10");
     }
 
     function test_multiplication() public pure {
         Fixed18 a = Fixed18Lib.from(20);
         Fixed18 b = Fixed18Lib.from(10);
-        assertEq(Fixed18.unwrap(Fixed18Lib.mul(a, b)), 200e18, "20 * 10 = 200");
+        assertEq(Fixed18.unwrap(a * b), 200e18, "20 * 10 = 200");
         a = Fixed18Lib.from(-20);
-        assertEq(Fixed18.unwrap(Fixed18Lib.mul(a, b)), -200e18, "-20 * 10 = -200");
+        assertEq(Fixed18.unwrap(a * b), -200e18, "-20 * 10 = -200");
         b = Fixed18Lib.from(-10);
-        assertEq(Fixed18.unwrap(Fixed18Lib.mul(a, b)), 200e18, "-20 * -10 = 200");
+        assertEq(Fixed18.unwrap(a * b), 200e18, "-20 * -10 = 200");
         a = Fixed18Lib.from(20);
-        assertEq(Fixed18.unwrap(Fixed18Lib.mul(a, b)), -200e18, "20 * -10 = -200");
+        assertEq(Fixed18.unwrap(a * b), -200e18, "20 * -10 = -200");
     }
 
     function test_MultiplicationRoundsTowardZero() public pure {
         Fixed18 a = Fixed18.wrap(1);
         Fixed18 b = Fixed18.wrap(2);
-        assertEq(Fixed18.unwrap(Fixed18Lib.mul(a, b)), 0, "0.000000000_000000001 * 0.000000000_000000002 = 0");
+        assertEq(Fixed18.unwrap(a * b), 0, "0.000000000_000000001 * 0.000000000_000000002 = 0");
         a = Fixed18.wrap(-1);
-        assertEq(Fixed18.unwrap(Fixed18Lib.mul(a, b)), 0, "-0.000000000_000000001 * 0.000000000_000000002 = 0");
+        assertEq(Fixed18.unwrap(a * b), 0, "-0.000000000_000000001 * 0.000000000_000000002 = 0");
         b = Fixed18.wrap(-2);
-        assertEq(Fixed18.unwrap(Fixed18Lib.mul(a, b)), 0, "-0.000000000_000000001 * -0.000000000_000000002 = 0");
+        assertEq(Fixed18.unwrap(a * b), 0, "-0.000000000_000000001 * -0.000000000_000000002 = 0");
         a = Fixed18.wrap(1);
-        assertEq(Fixed18.unwrap(Fixed18Lib.mul(a, b)), 0, "0.000000000_000000001 * -0.000000000_000000002 = 0");
+        assertEq(Fixed18.unwrap(a * b), 0, "0.000000000_000000001 * -0.000000000_000000002 = 0");
     }
 
     function test_multiplicationOut() public pure {
@@ -186,21 +186,21 @@ contract Fixed18Test is Test {
     function test_division() public pure {
         Fixed18 a = Fixed18Lib.from(20);
         Fixed18 b = Fixed18Lib.from(10);
-        assertEq(Fixed18.unwrap(Fixed18Lib.div(a, b)), 2e18, "20 / 10 = 2");
+        assertEq(Fixed18.unwrap(a / b), 2e18, "20 / 10 = 2");
         a = Fixed18Lib.from(-20);
-        assertEq(Fixed18.unwrap(Fixed18Lib.div(a, b)), -2e18, "-20 / 10 = -2");
+        assertEq(Fixed18.unwrap(a / b), -2e18, "-20 / 10 = -2");
         b = Fixed18Lib.from(-10);
-        assertEq(Fixed18.unwrap(Fixed18Lib.div(a, b)), 2e18, "-20 / -10 = 2");
+        assertEq(Fixed18.unwrap(a / b), 2e18, "-20 / -10 = 2");
         a = Fixed18Lib.from(20);
-        assertEq(Fixed18.unwrap(Fixed18Lib.div(a, b)), -2e18, "20 / -10 = -2");
+        assertEq(Fixed18.unwrap(a / b), -2e18, "20 / -10 = -2");
     }
 
     function test_divisionRoundsTowardsZero() public pure {
         Fixed18 a = Fixed18.wrap(21);
         Fixed18 b = Fixed18Lib.from(10);
-        assertEq(Fixed18.unwrap(Fixed18Lib.div(a, b)), 2, "0.000000000_000000021 / 0.000000000_000000010 = 2");
+        assertEq(Fixed18.unwrap(a / b), 2, "0.000000000_000000021 / 0.000000000_000000010 = 2");
         a = Fixed18.wrap(-21);
-        assertEq(Fixed18.unwrap(Fixed18Lib.div(a, b)), -2, "-0.000000000_000000021 / 0.000000000_000000010 = -2");
+        assertEq(Fixed18.unwrap(a / b), -2, "-0.000000000_000000021 / 0.000000000_000000010 = -2");
     }
 
     function test_divisionZeroByZero() public {
@@ -407,76 +407,88 @@ contract Fixed18Test is Test {
     function test_equals() public pure {
         Fixed18 a = Fixed18.wrap(12);
         Fixed18 b = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.eq(a, b), true, "12 == 12");
+        assertEq(a == b, true, "12 == 12");
         a = Fixed18.wrap(-12);
         b = Fixed18.wrap(-12);
-        assertEq(Fixed18Lib.eq(a, b), true, "-12 == -12");
+        assertEq(a == b, true, "-12 == -12");
         a = Fixed18.wrap(11);
         b = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.eq(a, b), false, "11 != 12");
+        assertEq(a == b, false, "11 != 12");
+    }
+
+    function test_notEquals() public pure {
+        Fixed18 a = Fixed18.wrap(12);
+        Fixed18 b = Fixed18.wrap(12);
+        assertEq(a != b, false, "12 != 12");
+        a = Fixed18.wrap(-12);
+        b = Fixed18.wrap(-12);
+        assertEq(a != b, false, "-12 != -12");
+        a = Fixed18.wrap(11);
+        b = Fixed18.wrap(12);
+        assertEq(a != b, true, "11 == 12");
     }
 
     function test_greaterThan() public pure {
         Fixed18 a = Fixed18.wrap(13);
         Fixed18 b = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.gt(a, b), true, "13 > 12");
+        assertEq(a > b, true, "13 > 12");
         a = Fixed18.wrap(-12);
         b = Fixed18.wrap(-13);
-        assertEq(Fixed18Lib.gt(a, b), true, "-12 > -13");
+        assertEq(a > b, true, "-12 > -13");
         a = Fixed18.wrap(12);
         b = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.gt(a, b), false, "12 !> 12");
+        assertEq(a > b, false, "12 !> 12");
         a = Fixed18.wrap(11);
-        assertEq(Fixed18Lib.gt(a, b), false, "11 !> 12");
+        assertEq(a > b, false, "11 !> 12");
     }
 
     function test_lessThan() public pure {
         Fixed18 a = Fixed18.wrap(13);
         Fixed18 b = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.lt(a, b), false, "13 !< 12");
+        assertEq(a < b, false, "13 !< 12");
         a = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.lt(a, b), false, "12 !< 12");
+        assertEq(a < b, false, "12 !< 12");
         a = Fixed18.wrap(11);
         b = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.lt(a, b), true, "11 < 12");
+        assertEq(a < b, true, "11 < 12");
         a = Fixed18.wrap(-12);
         b = Fixed18.wrap(-11);
-        assertEq(Fixed18Lib.lt(a, b), true, "-12 < -11");
+        assertEq(a < b, true, "-12 < -11");
     }
 
     function test_greaterThanOrEqualTo() public pure {
         Fixed18 a = Fixed18.wrap(13);
         Fixed18 b = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.gte(a, b), true, "13 >= 12");
+        assertEq(a >= b, true, "13 >= 12");
         a = Fixed18.wrap(-12);
         b = Fixed18.wrap(-13);
-        assertEq(Fixed18Lib.gte(a, b), true, "-12 >= -13");
+        assertEq(a >= b, true, "-12 >= -13");
         a = Fixed18.wrap(12);
         b = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.gte(a, b), true, "12 >= 12");
+        assertEq(a >= b, true, "12 >= 12");
         a = Fixed18.wrap(-12);
         b = Fixed18.wrap(-12);
-        assertEq(Fixed18Lib.gte(a, b), true, "-12 >= -12");
+        assertEq(a >= b, true, "-12 >= -12");
         a = Fixed18.wrap(11);
         b = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.gte(a, b), false, "11 !>= 12");
+        assertEq(a >= b, false, "11 !>= 12");
     }
 
     function test_lessThanOrEqualTo() public pure {
         Fixed18 a = Fixed18.wrap(13);
         Fixed18 b = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.lte(a, b), false, "13 !<= 12");
+        assertEq(a <= b, false, "13 !<= 12");
         a = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.lte(a, b), true, "12 <= 12");
+        assertEq(a <= b, true, "12 <= 12");
         a = Fixed18.wrap(-12);
         b = Fixed18.wrap(-12);
-        assertEq(Fixed18Lib.lte(a, b), true, "-12 <= -12");
+        assertEq(a <= b, true, "-12 <= -12");
         a = Fixed18.wrap(11);
         b = Fixed18.wrap(12);
-        assertEq(Fixed18Lib.lte(a, b), true, "11 <= 12");
+        assertEq(a <= b, true, "11 <= 12");
         a = Fixed18.wrap(-12);
         b = Fixed18.wrap(-11);
-        assertEq(Fixed18Lib.lte(a, b), true, "-12 <= -11");
+        assertEq(a <= b, true, "-12 <= -11");
     }
 
     function test_compare() public pure {
@@ -613,7 +625,7 @@ contract MockFixed18 {
     }
 
     function div(Fixed18 a, Fixed18 b) external pure returns (Fixed18) {
-        return Fixed18Lib.div(a, b);
+        return a / b;
     }
 
     function divOut(Fixed18 a, Fixed18 b) external pure returns (Fixed18) {
diff --git a/test/number/Fixed6.t.sol b/test/number/Fixed6.t.sol
index 291bc733..439d47dc 100644
--- a/test/number/Fixed6.t.sol
+++ b/test/number/Fixed6.t.sol
@@ -126,45 +126,45 @@ contract Fixed6Test is Test {
     function test_addition() public pure {
         Fixed6 a = Fixed6Lib.from(10);
         Fixed6 b = Fixed6Lib.from(20);
-        assertEq(Fixed6.unwrap(Fixed6Lib.add(a, b)), 30e6, "10 + 20 = 30");
+        assertEq(Fixed6.unwrap(a + b), 30e6, "10 + 20 = 30");
 
         a = Fixed6Lib.from(-10);
         b = Fixed6Lib.from(-20);
-        assertEq(Fixed6.unwrap(Fixed6Lib.add(a, b)), -30e6, "-10 + -20 = -30");
+        assertEq(Fixed6.unwrap(a + b), -30e6, "-10 + -20 = -30");
     }
 
     function test_subtraction() public pure {
         Fixed6 a = Fixed6Lib.from(20);
         Fixed6 b = Fixed6Lib.from(10);
-        assertEq(Fixed6.unwrap(Fixed6Lib.sub(a, b)), 10e6, "20 - 10 = 10");
+        assertEq(Fixed6.unwrap(a - b), 10e6, "20 - 10 = 10");
 
         a = Fixed6Lib.from(-20);
         b = Fixed6Lib.from(-10);
-        assertEq(Fixed6.unwrap(Fixed6Lib.sub(a, b)), -10e6, "-20 - -10 = -10");
+        assertEq(Fixed6.unwrap(a - b), -10e6, "-20 - -10 = -10");
     }
 
     function test_multiplication() public pure {
         Fixed6 a = Fixed6Lib.from(20);
         Fixed6 b = Fixed6Lib.from(10);
-        assertEq(Fixed6.unwrap(Fixed6Lib.mul(a, b)), 200e6, "20 * 10 = 200");
+        assertEq(Fixed6.unwrap(a * b), 200e6, "20 * 10 = 200");
         a = Fixed6Lib.from(-20);
-        assertEq(Fixed6.unwrap(Fixed6Lib.mul(a, b)), -200e6, "-20 * 10 = -200");
+        assertEq(Fixed6.unwrap(a * b), -200e6, "-20 * 10 = -200");
         b = Fixed6Lib.from(-10);
-        assertEq(Fixed6.unwrap(Fixed6Lib.mul(a, b)), 200e6, "-20 * -10 = 200");
+        assertEq(Fixed6.unwrap(a * b), 200e6, "-20 * -10 = 200");
         a = Fixed6Lib.from(20);
-        assertEq(Fixed6.unwrap(Fixed6Lib.mul(a, b)), -200e6, "20 * -10 = -200");
+        assertEq(Fixed6.unwrap(a * b), -200e6, "20 * -10 = -200");
     }
 
     function test_MultiplicationRoundsTowardZero() public pure {
         Fixed6 a = Fixed6.wrap(1);
         Fixed6 b = Fixed6.wrap(2);
-        assertEq(Fixed6.unwrap(Fixed6Lib.mul(a, b)), 0, "0.0000001 * 0.0000002 = 0");
+        assertEq(Fixed6.unwrap(a * b), 0, "0.0000001 * 0.0000002 = 0");
         a = Fixed6.wrap(-1);
-        assertEq(Fixed6.unwrap(Fixed6Lib.mul(a, b)), 0, "-0.0000001 * 0.0000002 = 0");
+        assertEq(Fixed6.unwrap(a * b), 0, "-0.0000001 * 0.0000002 = 0");
         b = Fixed6.wrap(-2);
-        assertEq(Fixed6.unwrap(Fixed6Lib.mul(a, b)), 0, "-0.0000001 * -0.0000002 = 0");
+        assertEq(Fixed6.unwrap(a * b), 0, "-0.0000001 * -0.0000002 = 0");
         a = Fixed6.wrap(1);
-        assertEq(Fixed6.unwrap(Fixed6Lib.mul(a, b)), 0, "0.0000001 * -0.0000002 = 0");
+        assertEq(Fixed6.unwrap(a * b), 0, "0.0000001 * -0.0000002 = 0");
     }
 
     function test_multiplicationOut() public pure {
@@ -194,21 +194,21 @@ contract Fixed6Test is Test {
     function test_division() public pure {
         Fixed6 a = Fixed6.wrap(20);
         Fixed6 b = Fixed6.wrap(10);
-        assertEq(Fixed6.unwrap(Fixed6Lib.div(a, b)), 2e6, "20 / 10 = 2");
+        assertEq(Fixed6.unwrap(a / b), 2e6, "20 / 10 = 2");
         a = Fixed6.wrap(-20);
-        assertEq(Fixed6.unwrap(Fixed6Lib.div(a, b)), -2e6, "-20 / 10 = -2");
+        assertEq(Fixed6.unwrap(a / b), -2e6, "-20 / 10 = -2");
         b = Fixed6.wrap(-10);
-        assertEq(Fixed6.unwrap(Fixed6Lib.div(a, b)), 2e6, "-20 / -10 = 2");
+        assertEq(Fixed6.unwrap(a / b), 2e6, "-20 / -10 = 2");
         a = Fixed6.wrap(20);
-        assertEq(Fixed6.unwrap(Fixed6Lib.div(a, b)), -2e6, "20 / -10 = -2");
+        assertEq(Fixed6.unwrap(a / b), -2e6, "20 / -10 = -2");
     }
 
     function test_divisionRoundsTowardsZero() public pure {
         Fixed6 a = Fixed6.wrap(21);
         Fixed6 b = Fixed6Lib.from(10);
-        assertEq(Fixed6.unwrap(Fixed6Lib.div(a, b)), 2, "0.000021 / 0.000010 = 2");
+        assertEq(Fixed6.unwrap(a / b), 2, "0.000021 / 0.000010 = 2");
         a = Fixed6.wrap(-21);
-        assertEq(Fixed6.unwrap(Fixed6Lib.div(a, b)), -2, "-0.000021 / 0.000010 = -2");
+        assertEq(Fixed6.unwrap(a / b), -2, "-0.000021 / 0.000010 = -2");
     }
 
     function test_divisionZeroByZero() public {
@@ -415,76 +415,88 @@ contract Fixed6Test is Test {
     function test_equals() public pure {
         Fixed6 a = Fixed6.wrap(12);
         Fixed6 b = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.eq(a, b), true, "12 == 12");
+        assertEq(a == b, true, "12 == 12");
         a = Fixed6.wrap(-12);
         b = Fixed6.wrap(-12);
-        assertEq(Fixed6Lib.eq(a, b), true, "-12 == -12");
+        assertEq(a == b, true, "-12 == -12");
         a = Fixed6.wrap(11);
         b = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.eq(a, b), false, "11 != 12");
+        assertEq(a == b, false, "11 != 12");
+    }
+
+    function test_notEquals() public pure {
+        Fixed6 a = Fixed6.wrap(12);
+        Fixed6 b = Fixed6.wrap(12);
+        assertEq(a != b, false, "12 != 12");
+        a = Fixed6.wrap(-12);
+        b = Fixed6.wrap(-12);
+        assertEq(a != b, false, "-12 != -12");
+        a = Fixed6.wrap(11);
+        b = Fixed6.wrap(12);
+        assertEq(a != b, true, "11 == 12");
     }
 
     function test_greaterThan() public pure {
         Fixed6 a = Fixed6.wrap(13);
         Fixed6 b = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.gt(a, b), true, "13 > 12");
+        assertEq(a > b, true, "13 > 12");
         a = Fixed6.wrap(-12);
         b = Fixed6.wrap(-13);
-        assertEq(Fixed6Lib.gt(a, b), true, "-12 > -13");
+        assertEq(a > b, true, "-12 > -13");
         a = Fixed6.wrap(12);
         b = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.gt(a, b), false, "12 !> 12");
+        assertEq(a > b, false, "12 !> 12");
         a = Fixed6.wrap(11);
-        assertEq(Fixed6Lib.gt(a, b), false, "11 !> 12");
+        assertEq(a > b, false, "11 !> 12");
     }
 
     function test_lessThan() public pure {
         Fixed6 a = Fixed6.wrap(13);
         Fixed6 b = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.lt(a, b), false, "13 !< 12");
+        assertEq(a < b, false, "13 !< 12");
         a = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.lt(a, b), false, "12 !< 12");
+        assertEq(a < b, false, "12 !< 12");
         a = Fixed6.wrap(11);
         b = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.lt(a, b), true, "11 < 12");
+        assertEq(a < b, true, "11 < 12");
         a = Fixed6.wrap(-12);
         b = Fixed6.wrap(-11);
-        assertEq(Fixed6Lib.lt(a, b), true, "-12 < -11");
+        assertEq(a < b, true, "-12 < -11");
     }
 
     function test_greaterThanOrEqualTo() public pure {
         Fixed6 a = Fixed6.wrap(13);
         Fixed6 b = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.gte(a, b), true, "13 >= 12");
+        assertEq(a >= b, true, "13 >= 12");
         a = Fixed6.wrap(-12);
         b = Fixed6.wrap(-13);
-        assertEq(Fixed6Lib.gte(a, b), true, "-12 >= -13");
+        assertEq(a >= b, true, "-12 >= -13");
         a = Fixed6.wrap(12);
         b = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.gte(a, b), true, "12 >= 12");
+        assertEq(a >= b, true, "12 >= 12");
         a = Fixed6.wrap(-12);
         b = Fixed6.wrap(-12);
-        assertEq(Fixed6Lib.gte(a, b), true, "-12 >= -12");
+        assertEq(a >= b, true, "-12 >= -12");
         a = Fixed6.wrap(11);
         b = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.gte(a, b), false, "11 !>= 12");
+        assertEq(a >= b, false, "11 !>= 12");
     }
 
     function test_lessThanOrEqualTo() public pure {
         Fixed6 a = Fixed6.wrap(13);
         Fixed6 b = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.lte(a, b), false, "13 !<= 12");
+        assertEq(a <= b, false, "13 !<= 12");
         a = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.lte(a, b), true, "12 <= 12");
+        assertEq(a <= b, true, "12 <= 12");
         a = Fixed6.wrap(-12);
         b = Fixed6.wrap(-12);
-        assertEq(Fixed6Lib.lte(a, b), true, "-12 <= -12");
+        assertEq(a <= b, true, "-12 <= -12");
         a = Fixed6.wrap(11);
         b = Fixed6.wrap(12);
-        assertEq(Fixed6Lib.lte(a, b), true, "11 <= 12");
+        assertEq(a <= b, true, "11 <= 12");
         a = Fixed6.wrap(-12);
         b = Fixed6.wrap(-11);
-        assertEq(Fixed6Lib.lte(a, b), true, "-12 <= -11");
+        assertEq(a <= b, true, "-12 <= -11");
     }
 
     function test_compare() public pure {
@@ -621,7 +633,7 @@ contract MockFixed6 {
     }
 
     function div(Fixed6 a, Fixed6 b) external pure returns (Fixed6) {
-        return Fixed6Lib.div(a, b);
+        return a / b;
     }
 
     function divOut(Fixed6 a, Fixed6 b) external pure returns (Fixed6) {
diff --git a/test/number/UFixed18.t.sol b/test/number/UFixed18.t.sol
index 31fb4115..a0d354df 100644
--- a/test/number/UFixed18.t.sol
+++ b/test/number/UFixed18.t.sol
@@ -83,13 +83,13 @@ contract UFixed18Test is Test {
     function test_addition() public pure {
         UFixed18 a = UFixed18Lib.from(10);
         UFixed18 b = UFixed18Lib.from(20);
-        assertEq(UFixed18.unwrap(UFixed18Lib.add(a, b)), 30e18, "10 + 20 = 30");
+        assertEq(UFixed18.unwrap(a + b), 30e18, "10 + 20 = 30");
     }
 
     function test_subtraction() public pure {
         UFixed18 a = UFixed18Lib.from(20);
         UFixed18 b = UFixed18Lib.from(10);
-        assertEq(UFixed18.unwrap(UFixed18Lib.sub(a, b)), 10e18, "20 - 10 = 10");
+        assertEq(UFixed18.unwrap(a - b), 10e18, "20 - 10 = 10");
     }
 
     function test_subtractionRevertsIfNegative() public {
@@ -111,13 +111,13 @@ contract UFixed18Test is Test {
     function test_multiplication() public pure {
         UFixed18 a = UFixed18Lib.from(20);
         UFixed18 b = UFixed18Lib.from(10);
-        assertEq(UFixed18.unwrap(UFixed18Lib.mul(a, b)), 200e18, "20 * 10 = 200");
+        assertEq(UFixed18.unwrap(a * b), 200e18, "20 * 10 = 200");
     }
 
     function test_MultiplicationRoundsTowardZero() public pure {
         UFixed18 a = UFixed18.wrap(1);
         UFixed18 b = UFixed18.wrap(2);
-        assertEq(UFixed18.unwrap(UFixed18Lib.mul(a, b)), 0, "0.000000000_000000001 * 0.000000000_000000002 = 0");
+        assertEq(UFixed18.unwrap(a * b), 0, "0.000000000_000000001 * 0.000000000_000000002 = 0");
     }
 
     function test_multiplicationOut() public pure {
@@ -135,13 +135,13 @@ contract UFixed18Test is Test {
     function test_division() public pure {
         UFixed18 a = UFixed18.wrap(20);
         UFixed18 b = UFixed18.wrap(10);
-        assertEq(UFixed18.unwrap(UFixed18Lib.div(a, b)), 2e18, "20 / 10 = 2");
+        assertEq(UFixed18.unwrap(a / b), 2e18, "20 / 10 = 2");
     }
 
     function test_divisionRoundsTowardsZero() public pure {
         UFixed18 a = UFixed18.wrap(21);
         UFixed18 b = UFixed18Lib.from(10);
-        assertEq(UFixed18.unwrap(UFixed18Lib.div(a, b)), 2, "0.000000000_000000021 / 0.000000000_000000010 = 2");
+        assertEq(UFixed18.unwrap(a / b), 2, "0.000000000_000000021 / 0.000000000_000000010 = 2");
     }
 
     function test_divisionZeroByZero() public {
@@ -278,55 +278,64 @@ contract UFixed18Test is Test {
     function test_equals() public pure {
         UFixed18 a = UFixed18.wrap(12);
         UFixed18 b = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.eq(a, b), true, "12 == 12");
+        assertEq(a == b, true, "12 == 12");
         a = UFixed18.wrap(11);
         b = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.eq(a, b), false, "11 != 12");
+        assertEq(a == b, false, "11 != 12");
+    }
+
+    function test_notEquals() public pure {
+        UFixed18 a = UFixed18.wrap(12);
+        UFixed18 b = UFixed18.wrap(12);
+        assertEq(a != b, false, "12 != 12");
+        a = UFixed18.wrap(11);
+        b = UFixed18.wrap(12);
+        assertEq(a != b, true, "11 == 12");
     }
 
     function test_greaterThan() public pure {
         UFixed18 a = UFixed18.wrap(13);
         UFixed18 b = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.gt(a, b), true, "13 > 12");
+        assertEq(a > b, true, "13 > 12");
         a = UFixed18.wrap(12);
         b = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.gt(a, b), false, "12 !> 12");
+        assertEq(a > b, false, "12 !> 12");
         a = UFixed18.wrap(11);
-        assertEq(UFixed18Lib.gt(a, b), false, "11 !> 12");
+        assertEq(a > b, false, "11 !> 12");
     }
 
     function test_lessThan() public pure {
         UFixed18 a = UFixed18.wrap(13);
         UFixed18 b = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.lt(a, b), false, "13 !< 12");
+        assertEq(a < b, false, "13 !< 12");
         a = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.lt(a, b), false, "12 !< 12");
+        assertEq(a < b, false, "12 !< 12");
         a = UFixed18.wrap(11);
         b = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.lt(a, b), true, "11 < 12");
+        assertEq(a < b, true, "11 < 12");
     }
 
     function test_greaterThanOrEqualTo() public pure {
         UFixed18 a = UFixed18.wrap(13);
         UFixed18 b = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.gte(a, b), true, "13 >= 12");
+        assertEq(a >= b, true, "13 >= 12");
         a = UFixed18.wrap(12);
         b = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.gte(a, b), true, "12 >= 12");
+        assertEq(a >= b, true, "12 >= 12");
         a = UFixed18.wrap(11);
         b = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.gte(a, b), false, "11 !>= 12");
+        assertEq(a >= b, false, "11 !>= 12");
     }
 
     function test_lessThanOrEqualTo() public pure {
         UFixed18 a = UFixed18.wrap(13);
         UFixed18 b = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.lte(a, b), false, "13 !<= 12");
+        assertEq(a <= b, false, "13 !<= 12");
         a = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.lte(a, b), true, "12 <= 12");
+        assertEq(a <= b, true, "12 <= 12");
         a = UFixed18.wrap(11);
         b = UFixed18.wrap(12);
-        assertEq(UFixed18Lib.lte(a, b), true, "11 <= 12");
+        assertEq(a <= b, true, "11 <= 12");
     }
 
     function test_compare() public pure {
@@ -415,11 +424,11 @@ contract MockUFixed18 {
     }
 
     function sub(UFixed18 a, UFixed18 b) external pure returns (UFixed18) {
-        return UFixed18Lib.sub(a, b);
+        return a - b;
     }
 
     function div(UFixed18 a, UFixed18 b) external pure returns (UFixed18) {
-        return UFixed18Lib.div(a, b);
+        return a / b;
     }
 
     function divOut(UFixed18 a, UFixed18 b) external pure returns (UFixed18) {
diff --git a/test/number/UFixed6.t.sol b/test/number/UFixed6.t.sol
index 41170218..8176f776 100644
--- a/test/number/UFixed6.t.sol
+++ b/test/number/UFixed6.t.sol
@@ -87,20 +87,20 @@ contract UFixed6Test is Test {
     }
 
     function test_isZero() public pure {
-        assertEq(UFixed6Lib.isZero(UFixed6Lib.ZERO), true, "0 is zero");
-        assertEq(UFixed6Lib.isZero(UFixed6Lib.ONE), false, "1 is not zero");
+        assertEq(UFixed6Lib.ZERO.isZero(), true, "0 is zero");
+        assertEq(UFixed6Lib.ONE.isZero(), false, "1 is not zero");
     }
 
     function test_addition() public pure {
         UFixed6 a = UFixed6Lib.from(10);
         UFixed6 b = UFixed6Lib.from(20);
-        assertEq(UFixed6.unwrap(UFixed6Lib.add(a, b)), 30e6, "10 + 20 = 30");
+        assertEq(UFixed6.unwrap(a + b), 30e6, "10 + 20 = 30");
     }
 
     function test_subtraction() public pure {
         UFixed6 a = UFixed6Lib.from(20);
         UFixed6 b = UFixed6Lib.from(10);
-        assertEq(UFixed6.unwrap(UFixed6Lib.sub(a, b)), 10e6, "20 - 10 = 10");
+        assertEq(UFixed6.unwrap(a - b), 10e6, "20 - 10 = 10");
     }
 
     function test_subtractionRevertsIfNegative() public {
@@ -113,46 +113,46 @@ contract UFixed6Test is Test {
     function test_unsafeSubtraction() public pure {
         UFixed6 a = UFixed6Lib.from(10);
         UFixed6 b = UFixed6Lib.from(20);
-        assertEq(UFixed6.unwrap(UFixed6Lib.unsafeSub(a, b)), 0);
+        assertEq(UFixed6.unwrap(a.unsafeSub(b)), 0);
 
         a = UFixed6Lib.from(30);
-        assertEq(UFixed6.unwrap(UFixed6Lib.unsafeSub(a, b)), 10e6);
+        assertEq(UFixed6.unwrap(a.unsafeSub(b)), 10e6);
     }
 
     function test_multiplication() public pure {
         UFixed6 a = UFixed6Lib.from(20);
         UFixed6 b = UFixed6Lib.from(10);
-        assertEq(UFixed6.unwrap(UFixed6Lib.mul(a, b)), 200e6, "20 * 10 = 200");
+        assertEq(UFixed6.unwrap(a * b), 200e6, "20 * 10 = 200");
     }
 
     function test_MultiplicationRoundsTowardZero() public pure {
         UFixed6 a = UFixed6.wrap(1);
         UFixed6 b = UFixed6.wrap(2);
-        assertEq(UFixed6.unwrap(UFixed6Lib.mul(a, b)), 0, "0.0000001 * 0.0000002 = 0");
+        assertEq(UFixed6.unwrap(a * b), 0, "0.0000001 * 0.0000002 = 0");
     }
 
     function test_multiplicationOut() public pure {
         UFixed6 a = UFixed6Lib.from(20);
         UFixed6 b = UFixed6Lib.from(10);
-        assertEq(UFixed6.unwrap(UFixed6Lib.mulOut(a, b)), 200e6, "20 * 10 = 200");
+        assertEq(UFixed6.unwrap(a.mulOut(b)), 200e6, "20 * 10 = 200");
     }
 
     function test_multiplicationOutRoundsAwayFromZero() public pure {
         UFixed6 a = UFixed6.wrap(1);
         UFixed6 b = UFixed6.wrap(2);
-        assertEq(UFixed6.unwrap(UFixed6Lib.mulOut(a, b)), 1, "0.0000001 * 0.0000002 = 0.0000001");
+        assertEq(UFixed6.unwrap(a.mulOut(b)), 1, "0.0000001 * 0.0000002 = 0.0000001");
     }
 
     function test_division() public pure {
         UFixed6 a = UFixed6.wrap(20);
         UFixed6 b = UFixed6.wrap(10);
-        assertEq(UFixed6.unwrap(UFixed6Lib.div(a, b)), 2e6, "20 / 10 = 2");
+        assertEq(UFixed6.unwrap(a / b), 2e6, "20 / 10 = 2");
     }
 
     function test_divisionRoundsTowardsZero() public pure {
         UFixed6 a = UFixed6.wrap(21);
         UFixed6 b = UFixed6Lib.from(10);
-        assertEq(UFixed6.unwrap(UFixed6Lib.div(a, b)), 2, "0.000021 / 0.000010 = 2");
+        assertEq(UFixed6.unwrap(a / b), 2, "0.000021 / 0.000010 = 2");
     }
 
     function test_divisionZeroByZero() public {
@@ -217,25 +217,25 @@ contract UFixed6Test is Test {
 
     function test_mulDiv() public pure {
         UFixed6 a = UFixed6Lib.from(20);
-        assertEq(UFixed6.unwrap(UFixed6Lib.muldiv(a, 10e6, 2e6)), 100e6, "muldiv(Fixed6, uint256, uint256)");
+        assertEq(UFixed6.unwrap(a.muldiv(10e6, 2e6)), 100e6, "muldiv(Fixed6, uint256, uint256)");
 
         UFixed6 b = UFixed6Lib.from(10);
         UFixed6 c = UFixed6Lib.from(2);
-        assertEq(UFixed6.unwrap(UFixed6Lib.muldiv(a, b, c)), 100e6, "muldiv(uf6, uf6, uf6)");
+        assertEq(UFixed6.unwrap(a.muldivFixed(b, c)), 100e6, "muldiv(uf6, uf6, uf6)");
 
         a = UFixed6.wrap(1_111111);
         b = UFixed6.wrap(3_333333);
-        assertEq(UFixed6.unwrap(UFixed6Lib.muldiv(a, b, b)), 1_111111, "muldiv(uf6, uf6, uf6) precision");
+        assertEq(UFixed6.unwrap(a.muldivFixed(b, b)), 1_111111, "muldiv(uf6, uf6, uf6) precision");
     }
 
     function test_mulDivRoundsTowardsZero() public pure {
         UFixed6 a = UFixed6.wrap(1);
-        assertEq(UFixed6.unwrap(UFixed6Lib.muldiv(a, 21, 10)), 2, "muldiv(uf6, i, i) 1*21/10 = 2");
+        assertEq(UFixed6.unwrap(a.muldiv(21, 10)), 2, "muldiv(uf6, i, i) 1*21/10 = 2");
 
         a = UFixed6.wrap(1);
         UFixed6 b = UFixed6.wrap(21);
         UFixed6 c = UFixed6.wrap(10);
-        assertEq(UFixed6.unwrap(UFixed6Lib.muldiv(a, b, c)), 2, "muldiv(uf6, uf6, uf6) 1*21/10 = 2");
+        assertEq(UFixed6.unwrap(a.muldivFixed(b, c)), 2, "muldiv(uf6, uf6, uf6) 1*21/10 = 2");
     }
 
     function test_mulDivSignedRevertsIfDivisorIsZero() public {
@@ -254,28 +254,28 @@ contract UFixed6Test is Test {
 
     function test_mulDivOutFixed() public pure {
         UFixed6 a = UFixed6Lib.from(20);
-        assertEq(UFixed6.unwrap(UFixed6Lib.muldivOut(a, 10e6, 2e6)), 100e6, "muldivOut(uf6, uint256, uint256)");
+        assertEq(UFixed6.unwrap(a.muldivOut(10e6, 2e6)), 100e6, "muldivOut(uf6, uint256, uint256)");
 
         UFixed6 b = UFixed6Lib.from(10);
         UFixed6 c = UFixed6Lib.from(2);
-        assertEq(UFixed6.unwrap(UFixed6Lib.muldivOut(a, b, c)), 100e6, "muldivOut(uf6, uf6, uf6)");
+        assertEq(UFixed6.unwrap(a.muldivOutFixed(b, c)), 100e6, "muldivOut(uf6, uf6, uf6)");
 
         a = UFixed6.wrap(1_111111);
         uint256 bi = 333333;
-        assertEq(UFixed6.unwrap(UFixed6Lib.muldivOut(a, bi, bi)), 1_111111, "muldivOut(uf6, uint256, uint256) precision");
+        assertEq(UFixed6.unwrap(a.muldivOut(bi, bi)), 1_111111, "muldivOut(uf6, uint256, uint256) precision");
 
         b = UFixed6.wrap(333333);
-        assertEq(UFixed6.unwrap(UFixed6Lib.muldivOut(a, b, b)), 1_111111, "muldivOut(uf6, uf6, uf6) precision");
+        assertEq(UFixed6.unwrap(a.muldivOutFixed(b, b)), 1_111111, "muldivOut(uf6, uf6, uf6) precision");
     }
 
     function test_mulDivOutRoundsAwayFromZero() public pure {
         UFixed6 a = UFixed6.wrap(1);
-        assertEq(UFixed6.unwrap(UFixed6Lib.muldivOut(a, 21, 10)), 3, "muldivOut(uf6, uint256, uint256) 1*21/10 = 3");
+        assertEq(UFixed6.unwrap(a.muldivOut(21, 10)), 3, "muldivOut(uf6, uint256, uint256) 1*21/10 = 3");
 
         a = UFixed6.wrap(1);
         UFixed6 b = UFixed6.wrap(21);
         UFixed6 c = UFixed6.wrap(10);
-        assertEq(UFixed6.unwrap(UFixed6Lib.muldivOut(a, b, c)), 3, "muldivOut(uf6, uf6, uf6) 1*21/10 = 3");
+        assertEq(UFixed6.unwrap(a.muldivOutFixed(b, c)), 3, "muldivOut(uf6, uf6, uf6) 1*21/10 = 3");
     }
 
     function test_mulDivOutFixedRevertsIfDivisorIsZero() public {
@@ -289,67 +289,76 @@ contract UFixed6Test is Test {
     function test_equals() public pure {
         UFixed6 a = UFixed6.wrap(12);
         UFixed6 b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.eq(a, b), true, "12 == 12");
+        assertEq(a == b, true, "12 == 12");
         a = UFixed6.wrap(11);
         b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.eq(a, b), false, "11 != 12");
+        assertEq(a == b, false, "11 != 12");
+    }
+
+    function test_notEquals() public pure {
+        UFixed6 a = UFixed6.wrap(12);
+        UFixed6 b = UFixed6.wrap(12);
+        assertEq(a != b, false, "12 != 12");
+        a = UFixed6.wrap(11);
+        b = UFixed6.wrap(12);
+        assertEq(a != b, true, "11 == 12");
     }
 
     function test_greaterThan() public pure {
         UFixed6 a = UFixed6.wrap(13);
         UFixed6 b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.gt(a, b), true, "13 > 12");
+        assertEq(a > b, true, "13 > 12");
         a = UFixed6.wrap(12);
         b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.gt(a, b), false, "12 !> 12");
+        assertEq(a > b, false, "12 !> 12");
         a = UFixed6.wrap(11);
-        assertEq(UFixed6Lib.gt(a, b), false, "11 !> 12");
+        assertEq(a > b, false, "11 !> 12");
     }
 
     function test_lessThan() public pure {
         UFixed6 a = UFixed6.wrap(13);
         UFixed6 b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.lt(a, b), false, "13 !< 12");
+        assertEq(a < b, false, "13 !< 12");
         a = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.lt(a, b), false, "12 !< 12");
+        assertEq(a < b, false, "12 !< 12");
         a = UFixed6.wrap(11);
         b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.lt(a, b), true, "11 < 12");
+        assertEq(a < b, true, "11 < 12");
     }
 
     function test_greaterThanOrEqualTo() public pure {
         UFixed6 a = UFixed6.wrap(13);
         UFixed6 b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.gte(a, b), true, "13 >= 12");
+        assertEq(a >= b, true, "13 >= 12");
         a = UFixed6.wrap(12);
         b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.gte(a, b), true, "12 >= 12");
+        assertEq(a >= b, true, "12 >= 12");
         a = UFixed6.wrap(11);
         b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.gte(a, b), false, "11 !>= 12");
+        assertEq(a >= b, false, "11 !>= 12");
     }
 
     function test_lessThanOrEqualTo() public pure {
         UFixed6 a = UFixed6.wrap(13);
         UFixed6 b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.lte(a, b), false, "13 !<= 12");
+        assertEq(a <= b, false, "13 !<= 12");
         a = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.lte(a, b), true, "12 <= 12");
+        assertEq(a <= b, true, "12 <= 12");
         a = UFixed6.wrap(11);
         b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.lte(a, b), true, "11 <= 12");
+        assertEq(a <= b, true, "11 <= 12");
     }
 
     function test_compare() public pure {
         UFixed6 a = UFixed6.wrap(13);
         UFixed6 b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.compare(a, b), 2, "compare positive");
+        assertEq(a.compare(b), 2, "compare positive");
         a = UFixed6.wrap(12);
         b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.compare(a, b), 1, "compare zero");
+        assertEq(a.compare(b), 1, "compare zero");
         a = UFixed6.wrap(11);
         b = UFixed6.wrap(12);
-        assertEq(UFixed6Lib.compare(a, b), 0, "compare negative");
+        assertEq(a.compare(b), 0, "compare negative");
     }
 
     function test_ratio() public pure {
@@ -359,54 +368,54 @@ contract UFixed6Test is Test {
     function test_min() public pure {
         UFixed6 a = UFixed6.wrap(2000);
         UFixed6 b = UFixed6.wrap(100);
-        assertEq(UFixed6.unwrap(UFixed6Lib.min(a, b)), 100, "min(2000, 100) = 100");
+        assertEq(UFixed6.unwrap(a.min(b)), 100, "min(2000, 100) = 100");
         a = UFixed6.wrap(100);
         b = UFixed6.wrap(2000);
-        assertEq(UFixed6.unwrap(UFixed6Lib.min(a, b)), 100, "min(100, 2000) = 100");
+        assertEq(UFixed6.unwrap(a.min(b)), 100, "min(100, 2000) = 100");
     }
 
     function test_max() public pure {
         UFixed6 a = UFixed6.wrap(2000);
         UFixed6 b = UFixed6.wrap(100);
-        assertEq(UFixed6.unwrap(UFixed6Lib.max(a, b)), 2000, "max(2000, 100) = 2000");
+        assertEq(UFixed6.unwrap(a.max(b)), 2000, "max(2000, 100) = 2000");
         a = UFixed6.wrap(100);
         b = UFixed6.wrap(2000);
-        assertEq(UFixed6.unwrap(UFixed6Lib.max(a, b)), 2000, "max(100, 2000) = 2000");
+        assertEq(UFixed6.unwrap(a.max(b)), 2000, "max(100, 2000) = 2000");
     }
 
     function test_truncate() public pure {
         UFixed6 a = UFixed6.wrap(123_456000);
-        assertEq(UFixed6Lib.truncate(a), 123, "truncate returns floor");
+        assertEq(a.truncate(), 123, "truncate returns floor");
     }
 
     function test_inside() public pure {
         UFixed6 a = UFixed6.wrap(12);
         UFixed6 b = UFixed6.wrap(10);
         UFixed6 c = UFixed6.wrap(15);
-        assertEq(UFixed6Lib.inside(a, b, c), true, "inside");
+        assertEq(a.inside(b, c), true, "inside");
         a = UFixed6.wrap(10);
-        assertEq(UFixed6Lib.inside(a, b, c), true, "on lower bound");
+        assertEq(a.inside(b, c), true, "on lower bound");
         a = UFixed6.wrap(15);
-        assertEq(UFixed6Lib.inside(a, b, c), true, "on upper bound");
+        assertEq(a.inside(b, c), true, "on upper bound");
         a = UFixed6.wrap(9);
-        assertEq(UFixed6Lib.inside(a, b, c), false, "below lower bound");
+        assertEq(a.inside(b, c), false, "below lower bound");
         a = UFixed6.wrap(16);
-        assertEq(UFixed6Lib.inside(a, b, c), false, "above upper bound");
+        assertEq(a.inside(b, c), false, "above upper bound");
     }
 
     function test_outside() public pure {
         UFixed6 a = UFixed6.wrap(12);
         UFixed6 b = UFixed6.wrap(10);
         UFixed6 c = UFixed6.wrap(15);
-        assertEq(UFixed6Lib.outside(a, b, c), false, "inside");
+        assertEq(a.outside(b, c), false, "inside");
         a = UFixed6.wrap(10);
-        assertEq(UFixed6Lib.outside(a, b, c), false, "on lower bound");
+        assertEq(a.outside(b, c), false, "on lower bound");
         a = UFixed6.wrap(15);
-        assertEq(UFixed6Lib.outside(a, b, c), false, "on upper bound");
+        assertEq(a.outside(b, c), false, "on upper bound");
         a = UFixed6.wrap(9);
-        assertEq(UFixed6Lib.outside(a, b, c), true, "below lower bound");
+        assertEq(a.outside(b, c), true, "below lower bound");
         a = UFixed6.wrap(16);
-        assertEq(UFixed6Lib.outside(a, b, c), true, "above upper bound");
+        assertEq(a.outside(b, c), true, "above upper bound");
     }
 
     function test_store() public {
@@ -426,38 +435,38 @@ contract MockUFixed6 {
     }
 
     function sub(UFixed6 a, UFixed6 b) external pure returns (UFixed6) {
-        return UFixed6Lib.sub(a, b);
+        return a - b;
     }
 
     function div(UFixed6 a, UFixed6 b) external pure returns (UFixed6) {
-        return UFixed6Lib.div(a, b);
+        return a / b;
     }
 
     function divOut(UFixed6 a, UFixed6 b) external pure returns (UFixed6) {
-        return UFixed6Lib.divOut(a, b);
+        return a.divOut(b);
     }
 
     function unsafeDiv(UFixed6 a, UFixed6 b) external pure returns (UFixed6) {
-        return UFixed6Lib.unsafeDiv(a, b);
+        return a.unsafeDiv(b);
     }
 
     function unsafeDivOut(UFixed6 a, UFixed6 b) external pure returns (UFixed6) {
-        return UFixed6Lib.unsafeDivOut(a, b);
+        return a.unsafeDivOut(b);
     }
 
     function mulDiv(UFixed6 a, uint256 b, uint256 c) external pure returns (UFixed6) {
-        return UFixed6Lib.muldiv(a, b, c);
+        return a.muldiv(b, c);
     }
 
     function muldivFixed(UFixed6 a, UFixed6 b, UFixed6 c) external pure returns (UFixed6) {
-        return UFixed6Lib.muldiv(a, b, c);
+        return a.muldivFixed(b, c);
     }
 
     function muldivOut(UFixed6 a, uint256 b, uint256 c) external pure returns (UFixed6) {
-        return UFixed6Lib.muldivOut(a, b, c);
+        return a.muldivOut(b, c);
     }
 
     function muldivOutFixed(UFixed6 a, UFixed6 b, UFixed6 c) external pure returns (UFixed6) {
-        return UFixed6Lib.muldivOut(a, b, c);
+        return a.muldivOutFixed(b, c);
     }
 }
diff --git a/test/token/Token18.t.sol b/test/token/Token18.t.sol
index 5dd80540..446a1bba 100644
--- a/test/token/Token18.t.sol
+++ b/test/token/Token18.t.sol
@@ -7,10 +7,9 @@ import {
     Token18,
     Token18Lib,
     Token18Storage,
-    Token18StorageLib,
-    UFixed18,
-    UFixed18Lib
+    Token18StorageLib
 } from "../../src/token/types/Token18.sol";
+import { UFixed18, UFixed18Lib } from "../../src/number/types/UFixed18.sol";
 
 abstract contract Token18Test is TokenTest {
     Token18 public token;
diff --git a/test/token/Token6.t.sol b/test/token/Token6.t.sol
index 216b43c3..8e316079 100644
--- a/test/token/Token6.t.sol
+++ b/test/token/Token6.t.sol
@@ -7,10 +7,9 @@ import {
     Token6,
     Token6Lib,
     Token6Storage,
-    Token6StorageLib,
-    UFixed6,
-    UFixed6Lib
+    Token6StorageLib
 } from "../../src/token/types/Token6.sol";
+import { UFixed6, UFixed6Lib } from "../../src/number/types/UFixed6.sol";
 
 abstract contract Token6Test is TokenTest {
     Token6 public token;
diff --git a/test/utils/console.t.sol b/test/utils/console.t.sol
index dd253a17..013b57ac 100644
--- a/test/utils/console.t.sol
+++ b/test/utils/console.t.sol
@@ -4,8 +4,10 @@ pragma solidity ^0.8.13;
 
 import { Test } from "forge-std/Test.sol";
 
-import { Fixed6, Fixed6Lib, Fixed18, Fixed18Lib } from "../../src/number/types/Fixed6.sol";
-import { UFixed6, UFixed6Lib, UFixed18, UFixed18Lib } from "../../src/number/types/UFixed6.sol";
+import { Fixed6, Fixed6Lib } from "../../src/number/types/Fixed6.sol";
+import { Fixed18, Fixed18Lib } from "../../src/number/types/Fixed18.sol";
+import { UFixed6, UFixed6Lib } from "../../src/number/types/UFixed6.sol";
+import { UFixed18, UFixed18Lib } from "../../src/number/types/UFixed18.sol";
 
 import { console } from "../../src/utils/console.sol";
 


Reviews:
user: login: kbrizzle
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-08T05:52:45Z
user: login: kbrizzle
body: All comments are add-ons so feel free to merge if you'd rather do them as followups.
state: APPROVED
author_association: CONTRIBUTOR
submitted_at: 2025-04-08T05:53:33Z
user: login: EdNoepel
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-08T13:16:39Z
user: login: EdNoepel
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-08T13:27:03Z
user: login: kbrizzle
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-08T20:56:43Z
user: login: prateekdefi
body: LGTM
state: APPROVED
author_association: CONTRIBUTOR
submitted_at: 2025-04-09T06:55:58Z
user: login: EdNoepel
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-09T15:04:52Z

Review comments:
diff_hunk: @@ -21,7 +34,7 @@ library Fixed18Lib {
     /// @custom:error Arithmetic overflow
     error Fixed18OverflowError(uint256 value);
 
-    int256 private constant BASE = 1e18;
+    int256 internal constant BASE = 1e18;
     Fixed18 public constant ZERO = Fixed18.wrap(0);
path: src/number/types/Fixed18.sol
user: login: kbrizzle
body: should we make these ones `internal` as well? I didn't really constants only need to be internal to be used outside of the library.
created_at: 2025-04-08T05:46:19Z
author_association: CONTRIBUTOR
diff_hunk: @@ -373,3 +296,103 @@ library UFixed18StorageLib {
         }
     }
 }
+
+/**
+* @notice Adds two unsigned fixed-decimals `a` and `b` together
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Resulting summed unsigned fixed-decimal
+*/
+function add(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) + UFixed18.unwrap(b));
+}
+
+/**
+* @notice Subtracts unsigned fixed-decimal `b` from `a`
+* @param a Unsigned fixed-decimal to subtract from
+* @param b Unsigned fixed-decimal to subtract
+* @return Resulting subtracted unsigned fixed-decimal
+*/
+function sub(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) - UFixed18.unwrap(b));
+}
+
+/**
+* @notice Multiplies two unsigned fixed-decimals `a` and `b` together
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Resulting multiplied unsigned fixed-decimal
+*/
+function mul(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18.unwrap(b) / UFixed18Lib.BASE);
+}
+
+/**
+* @notice Divides unsigned fixed-decimal `a` by `b`
+* @param a Unsigned fixed-decimal to divide
+* @param b Unsigned fixed-decimal to divide by
+* @return Resulting divided unsigned fixed-decimal
+*/
+function div(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18Lib.BASE / UFixed18.unwrap(b));
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is equal to `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is equal to `b`
+*/
+function eq(UFixed18 a, UFixed18 b) pure returns (bool) {
+    return UFixed18Lib.compare(a, b) == 1;
path: src/number/types/UFixed18.sol
user: login: kbrizzle
body: For all of these comparison-based ones, is it actually cheaper to unwrap and compare natively?

Like: `UFixed18.unwrap(a) == UFixed18.unwrap(b)`.

This might have not been optimized when we first wrote it.
created_at: 2025-04-08T05:48:35Z
author_association: CONTRIBUTOR
diff_hunk: @@ -373,3 +296,103 @@ library UFixed18StorageLib {
         }
     }
 }
+
+/**
+* @notice Adds two unsigned fixed-decimals `a` and `b` together
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Resulting summed unsigned fixed-decimal
+*/
+function add(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) + UFixed18.unwrap(b));
+}
+
+/**
+* @notice Subtracts unsigned fixed-decimal `b` from `a`
+* @param a Unsigned fixed-decimal to subtract from
+* @param b Unsigned fixed-decimal to subtract
+* @return Resulting subtracted unsigned fixed-decimal
+*/
+function sub(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) - UFixed18.unwrap(b));
+}
+
+/**
+* @notice Multiplies two unsigned fixed-decimals `a` and `b` together
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Resulting multiplied unsigned fixed-decimal
+*/
+function mul(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18.unwrap(b) / UFixed18Lib.BASE);
+}
+
+/**
+* @notice Divides unsigned fixed-decimal `a` by `b`
+* @param a Unsigned fixed-decimal to divide
+* @param b Unsigned fixed-decimal to divide by
+* @return Resulting divided unsigned fixed-decimal
+*/
+function div(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18Lib.BASE / UFixed18.unwrap(b));
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is equal to `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is equal to `b`
+*/
+function eq(UFixed18 a, UFixed18 b) pure returns (bool) {
+    return UFixed18Lib.compare(a, b) == 1;
path: src/number/types/UFixed18.sol
user: login: EdNoepel
body: Certainly for `eq` and `neq`; comparison operators are expensive.  For the others, the jump to the _compare_ method is trivial compared to the cost of the < and > operators.

Here's some detail from gas testing:
as it was before: 
```
╭------------------------------------------------+-----------------+------+--------+------+---------╮
| test/number/Fixed18.t.sol:MockFixed18 Contract |                 |      |        |      |         |
+===================================================================================================+
| Function Name                                  | Min             | Avg  | Median | Max  | # Calls |
|------------------------------------------------+-----------------+------+--------+------+---------|
| gasTestEquals                                  | 999             | 1008 | 999    | 1024 | 64      |
╰------------------------------------------------+-----------------+------+--------+------+---------╯
```

eq and neq unwrapping and comparing natively:
```
╭------------------------------------------------+-----------------+------+--------+------+---------╮
| test/number/Fixed18.t.sol:MockFixed18 Contract |                 |      |        |      |         |
+===================================================================================================+
| Function Name                                  | Min             | Avg  | Median | Max  | # Calls |
|------------------------------------------------+-----------------+------+--------+------+---------|
| gasTestEquals                                  | 890             | 890  | 890    | 890  | 64      |
╰------------------------------------------------+-----------------+------+--------+------+---------╯
```
Improved in e495cea1f87ed709e67aee524d88fab89cf46b4e.
created_at: 2025-04-08T13:16:39Z
author_association: CONTRIBUTOR
diff_hunk: @@ -21,7 +34,7 @@ library Fixed18Lib {
     /// @custom:error Arithmetic overflow
     error Fixed18OverflowError(uint256 value);
 
-    int256 private constant BASE = 1e18;
+    int256 internal constant BASE = 1e18;
     Fixed18 public constant ZERO = Fixed18.wrap(0);
path: src/number/types/Fixed18.sol
user: login: EdNoepel
body: Indeed; a library merely needs to be imported for `internal` constants to be visible.  Updated in 2d2c1dfe736416bd3577370e738382d276142d23.
created_at: 2025-04-08T13:27:03Z
author_association: CONTRIBUTOR
diff_hunk: @@ -373,3 +296,103 @@ library UFixed18StorageLib {
         }
     }
 }
+
+/**
+* @notice Adds two unsigned fixed-decimals `a` and `b` together
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Resulting summed unsigned fixed-decimal
+*/
+function add(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) + UFixed18.unwrap(b));
+}
+
+/**
+* @notice Subtracts unsigned fixed-decimal `b` from `a`
+* @param a Unsigned fixed-decimal to subtract from
+* @param b Unsigned fixed-decimal to subtract
+* @return Resulting subtracted unsigned fixed-decimal
+*/
+function sub(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) - UFixed18.unwrap(b));
+}
+
+/**
+* @notice Multiplies two unsigned fixed-decimals `a` and `b` together
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Resulting multiplied unsigned fixed-decimal
+*/
+function mul(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18.unwrap(b) / UFixed18Lib.BASE);
+}
+
+/**
+* @notice Divides unsigned fixed-decimal `a` by `b`
+* @param a Unsigned fixed-decimal to divide
+* @param b Unsigned fixed-decimal to divide by
+* @return Resulting divided unsigned fixed-decimal
+*/
+function div(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18Lib.BASE / UFixed18.unwrap(b));
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is equal to `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is equal to `b`
+*/
+function eq(UFixed18 a, UFixed18 b) pure returns (bool) {
+    return UFixed18Lib.compare(a, b) == 1;
path: src/number/types/UFixed18.sol
user: login: kbrizzle
body: 😱 wow that's more than I thought, nice!

It might be worth doing for the comparison operators even if the win is much smaller since they're used repeatedly so many times through codebases.
created_at: 2025-04-08T20:56:43Z
author_association: CONTRIBUTOR
diff_hunk: @@ -373,3 +296,103 @@ library UFixed18StorageLib {
         }
     }
 }
+
+/**
+* @notice Adds two unsigned fixed-decimals `a` and `b` together
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Resulting summed unsigned fixed-decimal
+*/
+function add(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) + UFixed18.unwrap(b));
+}
+
+/**
+* @notice Subtracts unsigned fixed-decimal `b` from `a`
+* @param a Unsigned fixed-decimal to subtract from
+* @param b Unsigned fixed-decimal to subtract
+* @return Resulting subtracted unsigned fixed-decimal
+*/
+function sub(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) - UFixed18.unwrap(b));
+}
+
+/**
+* @notice Multiplies two unsigned fixed-decimals `a` and `b` together
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Resulting multiplied unsigned fixed-decimal
+*/
+function mul(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18.unwrap(b) / UFixed18Lib.BASE);
+}
+
+/**
+* @notice Divides unsigned fixed-decimal `a` by `b`
+* @param a Unsigned fixed-decimal to divide
+* @param b Unsigned fixed-decimal to divide by
+* @return Resulting divided unsigned fixed-decimal
+*/
+function div(UFixed18 a, UFixed18 b) pure returns (UFixed18) {
+    return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18Lib.BASE / UFixed18.unwrap(b));
+}
+
+/**
+* @notice Returns whether unsigned fixed-decimal `a` is equal to `b`
+* @param a First unsigned fixed-decimal
+* @param b Second unsigned fixed-decimal
+* @return Whether `a` is equal to `b`
+*/
+function eq(UFixed18 a, UFixed18 b) pure returns (bool) {
+    return UFixed18Lib.compare(a, b) == 1;
path: src/number/types/UFixed18.sol
user: login: EdNoepel
body: Sure.  Another impactful optimization I added was changing the order of evaluation for `gte` and `lte`, such the the `eq` runs first.  With both changes:

as it was before:
```
╭------------------------------------------------+-----------------+------+--------+------+---------╮
| test/number/Fixed18.t.sol:MockFixed18 Contract |                 |      |        |      |         |
+===================================================================================================+
| Function Name                                  | Min             | Avg  | Median | Max  | # Calls |
|------------------------------------------------+-----------------+------+--------+------+---------|
| compareGasTest                                 | 1509            | 1560 | 1609   | 1609 | 64      |
╰------------------------------------------------+-----------------+------+--------+------+---------╯
```

ignoring compare and reordering gte/lte terms:
```
╭------------------------------------------------+-----------------+------+--------+------+---------╮
| test/number/Fixed18.t.sol:MockFixed18 Contract |                 |      |        |      |         |
+===================================================================================================+
| Function Name                                  | Min             | Avg  | Median | Max  | # Calls |
|------------------------------------------------+-----------------+------+--------+------+---------|
| compareGasTest                                 | 1231            | 1231 | 1231   | 1231 | 64      |
╰------------------------------------------------+-----------------+------+--------+------+---------╯
```
Improved in 71187680394ccf7cfda2df87ce90e1998478431c.
created_at: 2025-04-09T15:04:52Z
author_association: CONTRIBUTOR

PR comments:
user: login: github-actions[bot]
created_at: 2025-04-07T20:29:09Z
body: # Slither report
  <details><summary>Static Analysis Report</summary>**THIS CHECKLIST IS NOT COMPLETE**. Use `--show-ignored-findings` to show all the results.
Summary
 - [unused-return](#unused-return) (4 results) (Medium)
 - [missing-zero-check](#missing-zero-check) (2 results) (Low)
 - [reentrancy-benign](#reentrancy-benign) (1 results) (Low)
 - [reentrancy-events](#reentrancy-events) (3 results) (Low)
 - [dead-code](#dead-code) (49 results) (Informational)
 - [solc-version](#solc-version) (2 results) (Informational)
 - [naming-convention](#naming-convention) (4 results) (Informational)
 - [too-many-digits](#too-many-digits) (1 results) (Informational)
## unused-return
Impact: Medium
Confidence: Medium
 - [ ] ID-0
[Token18Lib.approve(Token18,address)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token18.sol#L51-L53) ignores return value by [IERC20(Token18.unwrap(self)).approve(grantee,type()(uint256).max)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token18.sol#L52)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token18.sol#L51-L53


 - [ ] ID-1
[Token6Lib.approve(Token6,address,UFixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token6.sol#L64-L66) ignores return value by [IERC20(Token6.unwrap(self)).approve(grantee,UFixed6.unwrap(amount))](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token6.sol#L65)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token6.sol#L64-L66


 - [ ] ID-2
[Token6Lib.approve(Token6,address)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token6.sol#L51-L53) ignores return value by [IERC20(Token6.unwrap(self)).approve(grantee,type()(uint256).max)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token6.sol#L52)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token6.sol#L51-L53


 - [ ] ID-3
[Token18Lib.approve(Token18,address,UFixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token18.sol#L63-L65) ignores return value by [IERC20(Token18.unwrap(self)).approve(grantee,UFixed18.unwrap(amount))](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token18.sol#L64)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token18.sol#L63-L65


## missing-zero-check
Impact: Low
Confidence: Medium
 - [ ] ID-4
[Pausable.updatePauser(address).newPauser](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Pausable.sol#L38) lacks a zero-check on :
		- [_pauser = newPauser](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Pausable.sol#L39)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Pausable.sol#L38


 - [ ] ID-5
[Ownable.updatePendingOwner(address).newPendingOwner](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Ownable.sol#L37) lacks a zero-check on :
		- [_pendingOwner = newPendingOwner](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Ownable.sol#L38)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Ownable.sol#L37


## reentrancy-benign
Impact: Low
Confidence: Medium
 - [ ] ID-6
Reentrancy in [VerifierBase.cancelGroupWithSignature(GroupCancellation,bytes)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/VerifierBase.sol#L54-L57):
	External calls:
	- [IVerifierBase(this).verifyGroupCancellation(groupCancellation,signature)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/VerifierBase.sol#L55)
	State variables written after the call(s):
	- [_cancelGroup(groupCancellation.common.account,groupCancellation.group)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/VerifierBase.sol#L56)
		- [groups[account][group] = true](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/VerifierBase.sol#L79)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/VerifierBase.sol#L54-L57


## reentrancy-events
Impact: Low
Confidence: Medium
 - [ ] ID-7
Reentrancy in [Factory._create2(bytes,bytes32)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L49-L52):
	External calls:
	- [newInstance = IInstance(address(new BeaconProxy(address(this),data)))](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L50)
	Event emitted after the call(s):
	- [InstanceRegistered(newInstance)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L71)
		- [_register(newInstance)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L51)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L49-L52


 - [ ] ID-8
Reentrancy in [VerifierBase.cancelGroupWithSignature(GroupCancellation,bytes)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/VerifierBase.sol#L54-L57):
	External calls:
	- [IVerifierBase(this).verifyGroupCancellation(groupCancellation,signature)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/VerifierBase.sol#L55)
	Event emitted after the call(s):
	- [GroupCancelled(account,group)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/VerifierBase.sol#L80)
		- [_cancelGroup(groupCancellation.common.account,groupCancellation.group)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/VerifierBase.sol#L56)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/VerifierBase.sol#L54-L57


 - [ ] ID-9
Reentrancy in [Factory._create(bytes)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L40-L43):
	External calls:
	- [newInstance = IInstance(address(new BeaconProxy(address(this),data)))](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L41)
	Event emitted after the call(s):
	- [InstanceRegistered(newInstance)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L71)
		- [_register(newInstance)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L42)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L40-L43


## dead-code
Impact: Informational
Confidence: Medium
 - [ ] ID-10
[eq(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L346-L348) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L346-L348


 - [ ] ID-11
[add(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L340-L342) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L340-L342


 - [ ] ID-12
[Factory._register(IInstance)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L69-L72) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L69-L72


 - [ ] ID-13
[eq(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L354-L356) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L354-L356


 - [ ] ID-14
[add(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L330-L332) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L330-L332


 - [ ] ID-15
[mul(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L360-L362) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L360-L362


 - [ ] ID-16
[eq(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L380-L382) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L380-L382


 - [ ] ID-17
[gt(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L374-L377) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L374-L377


 - [ ] ID-18
[neq(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L390-L392) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L390-L392


 - [ ] ID-19
[mul(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L350-L352) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L350-L352


 - [ ] ID-20
[gt(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L400-L403) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L400-L403


 - [ ] ID-21
[lt(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L377-L380) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L377-L380


 - [ ] ID-22
[div(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L336-L338) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L336-L338


 - [ ] ID-23
[gte(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L396-L398) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L396-L398


 - [ ] ID-24
[sub(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L350-L352) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L350-L352


 - [ ] ID-25
[gte(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L422-L424) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L422-L424


 - [ ] ID-26
[Pausable.__Pausable__initialize()](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Pausable.sol#L28-L31) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Pausable.sol#L28-L31


 - [ ] ID-27
[mul(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L334-L336) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L334-L336


 - [ ] ID-28
[lte(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L432-L434) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L432-L434


 - [ ] ID-29
[Instance.__Instance__initialize()](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Instance.sol#L18-L20) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Instance.sol#L18-L20


 - [ ] ID-30
[lte(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L398-L400) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L398-L400


 - [ ] ID-31
[mul(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L326-L328) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L326-L328


 - [ ] ID-32
[lt(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L411-L414) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L411-L414


 - [ ] ID-33
[div(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L370-L372) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L370-L372


 - [ ] ID-34
[neq(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L356-L358) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L356-L358


 - [ ] ID-35
[Factory.__Factory__initialize()](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L25-L27) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L25-L27


 - [ ] ID-36
[div(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L360-L362) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L360-L362


 - [ ] ID-37
[lt(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L385-L388) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L385-L388


 - [ ] ID-38
[Ownable.__Ownable__initialize()](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Ownable.sol#L26-L29) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Ownable.sol#L26-L29


 - [ ] ID-39
[lt(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L401-L404) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L401-L404


 - [ ] ID-40
[gt(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L390-L393) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L390-L393


 - [ ] ID-41
[lte(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L422-L424) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L422-L424


 - [ ] ID-42
[eq(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L370-L372) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L370-L372


 - [ ] ID-43
[sub(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L316-L318) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L316-L318


 - [ ] ID-44
[neq(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L364-L366) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L364-L366


 - [ ] ID-45
[gt(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L366-L369) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L366-L369


 - [ ] ID-46
[gte(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L388-L390) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L388-L390


 - [ ] ID-47
[sub(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L324-L326) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L324-L326


 - [ ] ID-48
[Factory._create2(bytes,bytes32)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L49-L52) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L49-L52


 - [ ] ID-49
[Initializable._constructing()](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Initializable.sol#L45-L47) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Initializable.sol#L45-L47


 - [ ] ID-50
[add(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L314-L316) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L314-L316


 - [ ] ID-51
[Factory._computeCreate2Address(bytes,bytes32)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L58-L64) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L58-L64


 - [ ] ID-52
[sub(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L340-L342) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L340-L342


 - [ ] ID-53
[gte(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L412-L414) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L412-L414


 - [ ] ID-54
[Factory._create(bytes)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L40-L43) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L40-L43


 - [ ] ID-55
[lte(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L406-L408) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L406-L408


 - [ ] ID-56
[div(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L344-L346) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L344-L346


 - [ ] ID-57
[add(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L306-L308) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L306-L308


 - [ ] ID-58
[neq(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L380-L382) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L380-L382


## solc-version
Impact: Informational
Confidence: High
 - [ ] ID-59
Version constraint ^0.8.19 contains known severe issues (https://solidity.readthedocs.io/en/latest/bugs.html)
	- VerbatimInvalidDeduplication
	- FullInlinerNonExpressionSplitArgumentEvaluationOrder
	- MissingSideEffectsOnSelectorAccess.
It is used by:
	- [^0.8.19](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L2)
	- [^0.8.19](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed6.sol#L2)
	- [^0.8.19](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed6.sol#L2)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/Fixed18.sol#L2


 - [ ] ID-60
Version constraint ^0.8.13 contains known severe issues (https://solidity.readthedocs.io/en/latest/bugs.html)
	- VerbatimInvalidDeduplication
	- FullInlinerNonExpressionSplitArgumentEvaluationOrder
	- MissingSideEffectsOnSelectorAccess
	- StorageWriteRemovalBeforeConditionalTermination
	- AbiReencodingHeadOverflowWithStaticArrayCleanup
	- DirtyBytesArrayToStorage
	- InlineAssemblyMemorySideEffects
	- DataLocationChangeInInternalOverride
	- NestedCalldataArrayAbiReencodingSizeValidation.
It is used by:
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/access/ProxyOwner.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/accumulator/types/Accumulator6.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/accumulator/types/UAccumulator6.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Initializable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Instance.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Ownable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/OwnableStub.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/OwnerDelegatable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/OwnerExecutable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/OwnerWithdrawable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Pausable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/interfaces/IFactory.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/interfaces/IInitializable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/interfaces/IInstance.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/interfaces/IOwnable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/interfaces/IPausable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/NumberMath.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/number/types/UFixed18.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/synbook/types/SynBook6.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token18.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/token/types/Token6.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/utilization/CurveMath18.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/utilization/CurveMath6.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/utilization/types/JumpRateUtilizationCurve18.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/utilization/types/JumpRateUtilizationCurve6.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/utils/console.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/VerifierBase.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/interfaces/IVerifierBase.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/types/Common.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/verifier/types/GroupCancellation.sol#L2)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/access/ProxyOwner.sol#L2


## naming-convention
Impact: Informational
Confidence: High
 - [ ] ID-61
Function [Instance.__Instance__initialize()](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Instance.sol#L18-L20) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Instance.sol#L18-L20


 - [ ] ID-62
Function [Ownable.__Ownable__initialize()](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Ownable.sol#L26-L29) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Ownable.sol#L26-L29


 - [ ] ID-63
Function [Pausable.__Pausable__initialize()](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Pausable.sol#L28-L31) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Pausable.sol#L28-L31


 - [ ] ID-64
Function [Factory.__Factory__initialize()](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L25-L27) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L25-L27


## too-many-digits
Impact: Informational
Confidence: Medium
 - [ ] ID-65
[Factory._computeCreate2Address(bytes,bytes32)](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L58-L64) uses literals with too many digits:
	- [bytecode = abi.encodePacked(type()(BeaconProxy).creationCode,abi.encode(address(this),data))](https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L59-L62)

https://github.com/equilibria-xyz/root/blob/13e720658bda45cdac0096fc70c09a373db25689/src/attribute/Factory.sol#L58-L64


</details>
  <br/>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-04-09T15:03:25Z
body: <h2>Unit Test Coverage Report</h2>Coverage after merging <b>ed/pe-2398</b> into <b>v3</b> will be<table><tbody><tr><th>99.89%</th></tr></tbody></table>

<details><summary>Coverage Report</summary><table><tbody><tr><th>File</th><th>Stmts</th><th>Branches</th><th>Funcs</th><th>Lines</th><th>Uncovered Lines</th></tr><tr><td colspan='6'><b>src/access</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/access/ProxyOwner.sol'>ProxyOwner.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/accumulator/types</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/accumulator/types/Accumulator6.sol'>Accumulator6.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/accumulator/types/UAccumulator6.sol'>UAccumulator6.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/attribute</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/attribute/Factory.sol'>Factory.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/attribute/Initializable.sol'>Initializable.sol</a></td><td><b>88.24%</b></td><td><b>33.33%</b></td><td>100%</td><td>100%</td><td><a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/attribute/Initializable.sol#L23-L24'>23&ndash;24</a></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/attribute/Instance.sol'>Instance.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/attribute/Ownable.sol'>Ownable.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/attribute/OwnableStub.sol'>OwnableStub.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/attribute/OwnerDelegatable.sol'>OwnerDelegatable.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/attribute/OwnerExecutable.sol'>OwnerExecutable.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/attribute/OwnerWithdrawable.sol'>OwnerWithdrawable.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/attribute/Pausable.sol'>Pausable.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/number</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/number/NumberMath.sol'>NumberMath.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/number/types</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/number/types/Fixed18.sol'>Fixed18.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/number/types/Fixed6.sol'>Fixed6.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/number/types/UFixed18.sol'>UFixed18.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/number/types/UFixed6.sol'>UFixed6.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/synbook/types</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/synbook/types/SynBook6.sol'>SynBook6.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/token/types</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/token/types/Token18.sol'>Token18.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/token/types/Token6.sol'>Token6.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/utilization</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/utilization/CurveMath18.sol'>CurveMath18.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/utilization/CurveMath6.sol'>CurveMath6.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/utilization/types</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/utilization/types/JumpRateUtilizationCurve18.sol'>JumpRateUtilizationCurve18.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/utilization/types/JumpRateUtilizationCurve6.sol'>JumpRateUtilizationCurve6.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/utils</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/utils/console.sol'>console.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/verifier</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/verifier/VerifierBase.sol'>VerifierBase.sol</a></td><td><b>93.88%</b></td><td>100%</td><td><b>90%</b></td><td><b>93.55%</b></td><td><a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/verifier/VerifierBase.sol#L63-L64'>63&ndash;64</a></td></tr><tr><td colspan='6'><b>src/verifier/types</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/verifier/types/Common.sol'>Common.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/71187680394ccf7cfda2df87ce90e1998478431c/src/verifier/types/GroupCancellation.sol'>GroupCancellation.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr></tbody></table></details>
author_association: NONE