Repository: equilibria-xyz/root
Pull request #140: Add VRGDA
Author: login: kbrizzle
Created: 2025-05-12T06:30:19Z | Merged: 2025-05-21T22:35:09Z

Adds a [VRGDA](https://www.paradigm.xyz/2022/08/vrgda) package.

There are two types of VRGDAs, discrete (for ERC721s) and continuous (for ERC20s), this implements continuous VRGDAs.

Each VRGDA implementation has two components, the decay function and the issuance schedule. We aim to provide a modular framework for future expansion, but initially provide a single implementation with:
- Exponential decay function
- Linear issuance schedule

Additionally:
- Adds `.ln()` to fixed types
- Adds unary `-` custom operator to signed fixed types
- Adds additional `RootTest` helpers

Still To Do
- [x] Add `.ln()` method to other number types
- [x] Add unary `-` custom operator to `Fixed6`
- [x] Add tests for both new number methods
- [x] Evaluate TODOs in `VRGDA.t.sol` for additional test cases
- [x] Evaluate if `VRGDA.t.sol` should be split up into multiple files
- [x] See if any other coverage is necessary


Diff:
diff --git a/src/number/types/Fixed18.sol b/src/number/types/Fixed18.sol
index ca98ee1..ca0e93a 100644
--- a/src/number/types/Fixed18.sol
+++ b/src/number/types/Fixed18.sol
@@ -12,6 +12,7 @@ type Fixed18 is int256;
 using Fixed18Lib for Fixed18 global;
 
 using {
+    neg as -,
     add as +,
     sub as -,
     mul as *,
@@ -264,6 +265,20 @@ library Fixed18Lib {
     function exp(Fixed18 value) internal pure returns (Fixed18) {
         return Fixed18.wrap(SD59x18.unwrap(SD59x18.wrap(Fixed18.unwrap(value)).exp()));
     }
+
+    /// @notice Returns the natural logarithm of a signed fixed-decimal
+    /// @param value Signed fixed-decimal
+    /// @return Natural logarithm of `value`
+    function ln(Fixed18 value) internal pure returns (Fixed18) {
+        return Fixed18.wrap(SD59x18.unwrap(SD59x18.wrap(Fixed18.unwrap(value)).ln()));
+    }
+}
+
+/// @notice Returns the negation of a signed fixed-decimal
+/// @param a Signed fixed-decimal
+/// @return Negation of `a`
+function neg(Fixed18 a) pure returns (Fixed18) {
+    return Fixed18.wrap(-Fixed18.unwrap(a));
 }
 
 /// @notice Adds two signed fixed-decimals `a` and `b` together
diff --git a/src/number/types/Fixed6.sol b/src/number/types/Fixed6.sol
index c3f8dcd..fadece0 100644
--- a/src/number/types/Fixed6.sol
+++ b/src/number/types/Fixed6.sol
@@ -11,6 +11,7 @@ type Fixed6 is int256;
 using Fixed6Lib for Fixed6 global;
 
 using {
+    neg as -,
     add as +,
     sub as -,
     mul as *,
@@ -271,6 +272,20 @@ library Fixed6Lib {
     function exp(Fixed6 value) internal pure returns (Fixed6) {
         return from(Fixed18.wrap(SD59x18.unwrap(SD59x18.wrap(Fixed18.unwrap(Fixed18Lib.from(value))).exp())));
     }
+
+    /// @notice Returns the natural logarithm of a signed fixed-decimal
+    /// @param value Signed fixed-decimal
+    /// @return Natural logarithm of `value`
+    function ln(Fixed6 value) internal pure returns (Fixed6) {
+        return from(Fixed18.wrap(SD59x18.unwrap(SD59x18.wrap(Fixed18.unwrap(Fixed18Lib.from(value))).ln())));
+    }
+}
+
+/// @notice Returns the negation of a signed fixed-decimal
+/// @param a Signed fixed-decimal
+/// @return Negation of `a`
+function neg(Fixed6 a) pure returns (Fixed6) {
+    return Fixed6.wrap(-Fixed6.unwrap(a));
 }
 
 /// @notice Adds two signed fixed-decimals `a` and `b` together
diff --git a/src/number/types/UFixed18.sol b/src/number/types/UFixed18.sol
index 7fcc24c..114d642 100644
--- a/src/number/types/UFixed18.sol
+++ b/src/number/types/UFixed18.sol
@@ -240,6 +240,13 @@ library UFixed18Lib {
     function exp(UFixed18 value) internal pure returns (UFixed18) {
         return UFixed18.wrap(UD60x18.unwrap(UD60x18.wrap(UFixed18.unwrap(value)).exp()));
     }
+
+    /// @notice Returns the natural logarithm of a signed fixed-decimal
+    /// @param value Signed fixed-decimal
+    /// @return Natural logarithm of `value`
+    function ln(UFixed18 value) internal pure returns (UFixed18) {
+        return UFixed18.wrap(UD60x18.unwrap(UD60x18.wrap(UFixed18.unwrap(value)).ln()));
+    }
 }
 
 /// @notice Adds two unsigned fixed-decimals `a` and `b` together
diff --git a/src/number/types/UFixed6.sol b/src/number/types/UFixed6.sol
index 06d2223..9a4696e 100644
--- a/src/number/types/UFixed6.sol
+++ b/src/number/types/UFixed6.sol
@@ -247,6 +247,13 @@ library UFixed6Lib {
     function exp(UFixed6 value) internal pure returns (UFixed6) {
         return from(UFixed18.wrap(UD60x18.unwrap(UD60x18.wrap(UFixed18.unwrap(UFixed18Lib.from(value))).exp())));
     }
+
+    /// @notice Returns the natural logarithm of a signed fixed-decimal
+    /// @param value Signed fixed-decimal
+    /// @return Natural logarithm of `value`
+    function ln(UFixed6 value) internal pure returns (UFixed6) {
+        return from(UFixed18.wrap(UD60x18.unwrap(UD60x18.wrap(UFixed18.unwrap(UFixed18Lib.from(value))).ln())));
+    }
 }
 
 /// @notice Adds two unsigned fixed-decimals `a` and `b` together
diff --git a/src/vrgda/VRGDADecayMath.sol b/src/vrgda/VRGDADecayMath.sol
new file mode 100644
index 0000000..d705dca
--- /dev/null
+++ b/src/vrgda/VRGDADecayMath.sol
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.20;
+
+import { Fixed18, Fixed18Lib } from "../number/types/Fixed18.sol";
+import { UFixed18, UFixed18Lib } from "../number/types/UFixed18.sol";
+
+library VRGDADecayMath {
+    /// @dev current block.timestamp in days
+    function time() internal view returns (UFixed18) {
+        return UFixed18Lib.ratio(block.timestamp, 1 days);
+    }
+
+    /// @notice Returns the cost of a purchase over a continuous VRGDA with exponential decay
+    /// @param timestamp The timestamp of the start of the VRGDA
+    /// @param price The price coefficient of the VRGDA
+    /// @param decay The decay coefficient of the VRGDA
+    /// @param from Where the VRGDA has sold up to in its issuance schedule as of current block.timestamp (days)
+    /// @param to Where the VRGDA will have sold up to in its issuance schedule after the current purchase (days)
+    /// @return cost The cost of the purchase
+    function exponentialDecay(UFixed18 timestamp, UFixed18 price, UFixed18 decay, UFixed18 from, UFixed18 to) internal view returns (UFixed18 cost) {
+        (Fixed18 a, Fixed18 b) = (convert(timestamp + to), convert(timestamp + from));
+
+        Fixed18 sDecay = Fixed18Lib.from(decay);
+
+        return price * UFixed18Lib.from((-sDecay * a).exp() - (-sDecay * b).exp()) / decay;
+    }
+
+    /// @notice Returns time of the latest auction after the purchase over a continuous VRGDA with exponential decay
+    /// @param timestamp The timestamp of the start of the VRGDA
+    /// @param price The price coefficient of the VRGDA
+    /// @param decay The decay coefficient of the VRGDA
+    /// @param from The time of the latest auction relative to the start of the VRGDA
+    /// @param cost The cost of the purchase
+    /// @return to The time of the latest auction after the purchase relative to the start of the VRGDA
+    function exponentialDecayI(UFixed18 timestamp, UFixed18 price, UFixed18 decay, UFixed18 from, UFixed18 cost) internal view returns (UFixed18 to) {
+        Fixed18 b = convert(timestamp + from);
+
+        (Fixed18 sDecay, Fixed18 sPrice, Fixed18 sCost) = (Fixed18Lib.from(decay), Fixed18Lib.from(price), Fixed18Lib.from(cost));
+
+        // increase precision by inverting the input to exp() if b is negative
+        Fixed18 exp = b >= Fixed18Lib.ZERO ? sPrice / (sDecay * b).exp() : sPrice * (-sDecay * b).exp();
+
+        Fixed18 a = ln(sPrice, (sCost * sDecay + exp)) / sDecay;
+
+        return convert(a) - timestamp;
+    }
+
+    /// @dev Converts from an auction time to a time since auction
+    function convert(UFixed18 auctionTime) internal view returns (Fixed18) {
+        return Fixed18Lib.from(time()) - Fixed18Lib.from(auctionTime);
+    }
+
+    /// @dev Converts from a time since auction to an auction time
+    function convert(Fixed18 timeSince) internal view returns (UFixed18) {
+        return UFixed18Lib.from(Fixed18Lib.from(time()) - timeSince);
+    }
+
+    /// @notice Increased-precision natural logarithm
+    /// @dev Inverses the input of the natural logarithm if the input is less than 1 to increase precision
+    /// @param num The numerator of the input
+    /// @param den The denominator of the input
+    /// @return The natural logarithm of num / den
+    function ln(Fixed18 num, Fixed18 den) internal pure returns (Fixed18) {
+        return num >= den ? (num / den).ln() : -(den / num).ln();
+    }
+}
diff --git a/src/vrgda/VRGDAIssuanceMath.sol b/src/vrgda/VRGDAIssuanceMath.sol
new file mode 100644
index 0000000..d6e9a6e
--- /dev/null
+++ b/src/vrgda/VRGDAIssuanceMath.sol
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.20;
+
+import { UFixed18 } from "../number/types/UFixed18.sol";
+
+library VRGDAIssuanceMath {
+    /// @notice Returns the issuance of a VRGDA with linear issuance
+    /// @dev issued = auction * emission
+    ///      emission tokens will be issued per day of auctions
+    /// @param emission The emission coefficient of the VRGDA
+    /// @param auction The auction time relative to the start of the VRGDA
+    /// @return issued The issued amount at the auction time
+    function linearIssuance(UFixed18 emission, UFixed18 auction) internal pure returns (UFixed18) {
+        return auction * emission;
+    }
+
+    /// @dev auction = issued / emission
+    function linearIssuanceI(UFixed18 emission, UFixed18 issued) internal pure returns (UFixed18) {
+        return issued / emission;
+    }
+}
diff --git a/src/vrgda/types/LinearExponentialVRGDA.sol b/src/vrgda/types/LinearExponentialVRGDA.sol
new file mode 100644
index 0000000..e16cc75
--- /dev/null
+++ b/src/vrgda/types/LinearExponentialVRGDA.sol
@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.20;
+
+import { UFixed18 } from "../../number/types/UFixed18.sol";
+import { VRGDADecayMath } from "../VRGDADecayMath.sol";
+import { VRGDAIssuanceMath } from "../VRGDAIssuanceMath.sol";
+
+// TODO: change time to year for bounds?
+struct LinearExponentialVRGDA {
+    UFixed18 timestamp; // block timestamp of the start of the auction (seconds)
+    UFixed18 price; // Price coefficient of the VRGDA per token (k)
+    UFixed18 decay; // Decay coefficient of the VRGDA per day
+    UFixed18 emission; // tokens per day
+}
+using LinearExponentialVRGDALib for LinearExponentialVRGDA global;
+
+/// @title Linear Exponential Variable Rate Gradual Dutch Auctions
+library LinearExponentialVRGDALib {
+    /// @notice Returns the cost to purchase a specified amount of tokens
+    /// @param self VRGDA parameters
+    /// @param issued Number of tokens currently issued by the auction
+    /// @param amount The amount of tokens to purchase
+    /// @return Cost of the purchase
+    function toCost(LinearExponentialVRGDA memory self, UFixed18 issued, UFixed18 amount) internal view returns (UFixed18) {
+        return VRGDADecayMath.exponentialDecay(
+            self.timestamp,
+            self.price,
+            self.decay,
+            VRGDAIssuanceMath.linearIssuanceI(self.emission, issued),
+            VRGDAIssuanceMath.linearIssuanceI(self.emission, issued + amount)
+        );
+    }
+
+    /// @notice Returns the amount of tokens that can be purchased for a specified cost
+    /// @param self VRGDA parameters
+    /// @param issued Number of tokens currently issued by the auction
+    /// @param cost Funds to spend on the purchase
+    /// @return Amount of tokens that can be purchased
+    function toAmount(LinearExponentialVRGDA memory self, UFixed18 issued, UFixed18 cost) internal view returns (UFixed18) {
+        return VRGDAIssuanceMath.linearIssuance(
+            self.emission,
+            VRGDADecayMath.exponentialDecayI(
+                self.timestamp,
+                self.price,
+                self.decay,
+                VRGDAIssuanceMath.linearIssuanceI(self.emission, issued),
+                cost
+            )
+        ) - issued;
+    }
+}
diff --git a/test/RootTest.sol b/test/RootTest.sol
index 4a71f4a..5f8cd1b 100644
--- a/test/RootTest.sol
+++ b/test/RootTest.sol
@@ -50,4 +50,12 @@ contract RootTest is Test {
     function assertEq(Version a, Version b, string memory message) public pure {
         assertEq(Version.unwrap(a), Version.unwrap(b), message);
     }
+
+    function boundFixed18(Fixed18 x, Fixed18 min, Fixed18 max) internal pure virtual returns (Fixed18 result) {
+        result = Fixed18.wrap(_bound(Fixed18.unwrap(x), Fixed18.unwrap(min), Fixed18.unwrap(max)));
+    }
+
+    function boundUFixed18(UFixed18 x, UFixed18 min, UFixed18 max) internal pure virtual returns (UFixed18 result) {
+        result = UFixed18.wrap(_bound(UFixed18.unwrap(x), UFixed18.unwrap(min), UFixed18.unwrap(max)));
+    }
 }
diff --git a/test/number/Fixed18.t.sol b/test/number/Fixed18.t.sol
index 8eba376..c5dff80 100644
--- a/test/number/Fixed18.t.sol
+++ b/test/number/Fixed18.t.sol
@@ -115,6 +115,11 @@ contract Fixed18Test is Test {
         assertEq(Fixed18Lib.isZero(Fixed18Lib.NEG_ONE), false, "-1 is not zero");
     }
 
+    function test_neg() public pure {
+        Fixed18 a = Fixed18Lib.from(10);
+        assertEq(Fixed18.unwrap(-a), -10e18, "-10 = neg(10)");
+    }
+
     function test_addition() public pure {
         Fixed18 a = Fixed18Lib.from(10);
         Fixed18 b = Fixed18Lib.from(20);
@@ -611,6 +616,15 @@ contract Fixed18Test is Test {
         assertEq(Fixed18.unwrap(Fixed18Lib.exp(Fixed18.wrap(-0.5e18))), 606530659712633424, "exp(-0.5) = 0.606530659712633424");
         assertEq(Fixed18.unwrap(Fixed18Lib.exp(Fixed18.wrap(-5))), 999999999999999996, "exp(-5 * 10^-18) = 0.999999999999999996");
     }
+
+    function test_ln() public pure {
+        assertEq(Fixed18.unwrap(Fixed18Lib.ln(Fixed18Lib.from(1))), 0, "ln(1) = 0");
+        assertEq(Fixed18.unwrap(Fixed18Lib.ln(Fixed18Lib.from(2))), 693147180559945309, "ln(2) = 0.693147180559945309");
+        assertEq(Fixed18.unwrap(Fixed18Lib.ln(Fixed18Lib.from(3))), 1_098612288668109680, "ln(3) = 1.098612288668109680");
+        assertEq(Fixed18.unwrap(Fixed18Lib.ln(Fixed18Lib.from(10))), 2_302585092994045674, "ln(10) = 2.302585092994045674");
+        assertEq(Fixed18.unwrap(Fixed18Lib.ln(Fixed18.wrap(0.5e18))), -693147180559945309, "ln(0.5) = -0.693147180559945309");
+        assertEq(Fixed18.unwrap(Fixed18Lib.ln(Fixed18.wrap(5))), -39_837093761458721938, "ln(5 * 10^-18) = -39_837093761458721938");
+    }
 }
 
 contract MockFixed18 {
diff --git a/test/number/Fixed6.t.sol b/test/number/Fixed6.t.sol
index 9b48c03..41e95af 100644
--- a/test/number/Fixed6.t.sol
+++ b/test/number/Fixed6.t.sol
@@ -123,6 +123,11 @@ contract Fixed6Test is Test {
         assertEq(Fixed6Lib.isZero(Fixed6Lib.NEG_ONE), false, "-1 is not zero");
     }
 
+    function test_neg() public pure {
+        Fixed6 a = Fixed6Lib.from(10);
+        assertEq(Fixed6.unwrap(-a), -10e6, "-10 = neg(10)");
+    }
+
     function test_addition() public pure {
         Fixed6 a = Fixed6Lib.from(10);
         Fixed6 b = Fixed6Lib.from(20);
@@ -619,6 +624,15 @@ contract Fixed6Test is Test {
         assertEq(Fixed6.unwrap(Fixed6Lib.exp(Fixed6.wrap(-0.5e6))), 606530, "exp(-0.5) = 0.606530");
         assertEq(Fixed6.unwrap(Fixed6Lib.exp(Fixed6.wrap(-5))), 999995, "exp(-0.000005) = 0.999995");
     }
+
+    function test_ln() public pure {
+        assertEq(Fixed6.unwrap(Fixed6Lib.ln(Fixed6Lib.from(1))), 0, "ln(1) = 0");
+        assertEq(Fixed6.unwrap(Fixed6Lib.ln(Fixed6Lib.from(2))), 693147, "ln(2) = 0.693147");
+        assertEq(Fixed6.unwrap(Fixed6Lib.ln(Fixed6Lib.from(3))), 1_098612, "ln(3) = 1.098612");
+        assertEq(Fixed6.unwrap(Fixed6Lib.ln(Fixed6Lib.from(10))), 2_302585, "ln(10) = 2.302585");
+        assertEq(Fixed6.unwrap(Fixed6Lib.ln(Fixed6.wrap(0.5e6))), -693147, "ln(0.5) = -0.693147");
+        assertEq(Fixed6.unwrap(Fixed6Lib.ln(Fixed6.wrap(5))), -12_206072, "ln(0.000005) = -12.206072");
+    }
 }
 
 contract MockFixed6 {
diff --git a/test/number/UFixed18.t.sol b/test/number/UFixed18.t.sol
index 9f23118..8601637 100644
--- a/test/number/UFixed18.t.sol
+++ b/test/number/UFixed18.t.sol
@@ -416,6 +416,13 @@ contract UFixed18Test is Test {
         assertEq(UFixed18.unwrap(UFixed18Lib.exp(UFixed18.wrap(0.5e18))), 1_648721270700128145, "exp(0.5) = 1.648721270700128145");
         assertEq(UFixed18.unwrap(UFixed18Lib.exp(UFixed18.wrap(5))), 1_000000000000000004, "exp(5 * 10^-18) = 1.000000000000000004");
     }
+
+    function test_ln() public pure {
+        assertEq(UFixed18.unwrap(UFixed18Lib.ln(UFixed18Lib.from(1))), 0, "ln(1) = 0");
+        assertEq(UFixed18.unwrap(UFixed18Lib.ln(UFixed18Lib.from(2))), 693147180559945309, "ln(2) = 0.693147180559945309");
+        assertEq(UFixed18.unwrap(UFixed18Lib.ln(UFixed18Lib.from(3))), 1_098612288668109680, "ln(3) = 1.098612288668109680");
+        assertEq(UFixed18.unwrap(UFixed18Lib.ln(UFixed18Lib.from(10))), 2_302585092994045674, "ln(10) = 2.302585092994045674");
+    }
 }
 
 contract MockUFixed18 {
diff --git a/test/number/UFixed6.t.sol b/test/number/UFixed6.t.sol
index ecb3c61..93154f9 100644
--- a/test/number/UFixed6.t.sol
+++ b/test/number/UFixed6.t.sol
@@ -427,6 +427,13 @@ contract UFixed6Test is Test {
         assertEq(UFixed6.unwrap(UFixed6Lib.exp(UFixed6.wrap(0.5e6))), 1_648721, "exp(0.5) = 1.648721");
         assertEq(UFixed6.unwrap(UFixed6Lib.exp(UFixed6.wrap(5))), 1_000005, "exp(0.000005) = 1.000005");
     }
+
+    function test_ln() public pure {
+        assertEq(UFixed6.unwrap(UFixed6Lib.ln(UFixed6Lib.from(1))), 0, "ln(1) = 0");
+        assertEq(UFixed6.unwrap(UFixed6Lib.ln(UFixed6Lib.from(2))), 693147, "ln(2) = 0.693147");
+        assertEq(UFixed6.unwrap(UFixed6Lib.ln(UFixed6Lib.from(3))), 1_098612, "ln(3) = 1.098612");
+        assertEq(UFixed6.unwrap(UFixed6Lib.ln(UFixed6Lib.from(10))), 2_302585, "ln(10) = 2.302585");
+    }
 }
 
 contract MockUFixed6 {
diff --git a/test/vrgda/LinearExponentialVRGDA.t.sol b/test/vrgda/LinearExponentialVRGDA.t.sol
new file mode 100644
index 0000000..e19457d
--- /dev/null
+++ b/test/vrgda/LinearExponentialVRGDA.t.sol
@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import { UFixed18, UFixed18Lib } from "../../src/number/types/UFixed18.sol";
+import { LinearExponentialVRGDA } from "../../src/vrgda/types/LinearExponentialVRGDA.sol";
+import { RootTest } from "../RootTest.sol";
+
+contract LinearExponentialVRGDATest is RootTest {
+    LinearExponentialVRGDA vrgda;
+    UFixed18 issued;
+
+    function setUp() public {
+        vrgda = LinearExponentialVRGDA({
+            timestamp: UFixed18Lib.from(block.timestamp),
+            price: UFixed18Lib.from(100),
+            decay: UFixed18Lib.from(10),
+            emission: UFixed18Lib.from(200) // 200 tokens per day
+        });
+    }
+
+    function test_costDecreasesWhenBehind() public {
+        // initial cost to purchase 1 token quite high
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(1)), UFixed18.wrap(11_291.903496976_577338030e18));
+        // cost to move ahead of issuance schedule is higher
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(100)), UFixed18.wrap(32_466_151.192919613_034886620e18));
+
+        // after 1 day with nothing sold, cost to purchase 100 tokens is reasonable, and purchase is made
+        skip(1 days);
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(100)), UFixed18.wrap(1_473.960983816_764210610e18));
+        issued = UFixed18Lib.from(100);
+        // price increases as a result, but we're still behind
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(100)), UFixed18.wrap(218_755.206002187_764655650e18));
+
+        // after half a day, price becomes reasonable again, and continues to decrease
+        skip(12 hours);
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(100)), UFixed18.wrap(1_473.960983816_764210610e18));
+        skip(12 hours);
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(100)), UFixed18.wrap(9.931470987_677229170e18));
+    }
+
+    function test_amountIncreasesWhenBehind() public {
+        // after 1 day, 200 tokens have been purchased, even with issuance schedule
+        skip(1 days);
+        issued = UFixed18Lib.from(200);
+        // a 5k purchase would buy us 200 tokens
+        assertUFixed18Eq(vrgda.toAmount(issued, UFixed18Lib.from(5_000)), UFixed18.wrap(0.448974472_612174000e18));
+
+        // 8 hours later we would be behind issuance schedule, and should be able to purchase more tokens
+        skip(8 hours);
+        assertUFixed18Eq(vrgda.toAmount(issued, UFixed18Lib.from(5_000)), UFixed18.wrap(9.849858676_957755400e18));
+
+        // after 4 days, should be able to purchase considerably more
+        skip(3 days + 16 hours);
+        assertUFixed18Eq(vrgda.toAmount(issued, UFixed18Lib.from(5_000)), UFixed18.wrap(724.294476783_258653200e18));
+    }
+
+    function test_amountDecreasesWhenAhead() public {
+        // after 1 day, 200 tokens have been purchased, even with issuance schedule
+        skip(1 days);
+        issued = UFixed18Lib.from(200);
+        // a 50k purchase would buy us 4 tokens
+        assertUFixed18Eq(vrgda.toAmount(issued, UFixed18Lib.from(50_000)), UFixed18.wrap(4.091865860_077915200e18));
+
+        // if someone purchases 100 tokens, the same 50k purchase would buy us almost nothing
+        issued = issued + UFixed18Lib.from(100);
+        assertUFixed18Eq(vrgda.toAmount(issued, UFixed18Lib.from(50_000)), UFixed18.wrap(0.030570397_153121600e18));
+
+        // if even more overbought, the amount we can purchase becomes infinitesimal
+        issued = issued + UFixed18Lib.from(200);
+        assertUFixed18Eq(vrgda.toAmount(issued, UFixed18Lib.from(50_000)), UFixed18.wrap(0.000001388_955087400e18));
+    }
+
+    function test_costIncreasesWhenAhead() public {
+        // after 1 day, 200 tokens have been purchased, even with issuance schedule
+        skip(1 days);
+        issued = UFixed18Lib.from(200);
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(1)), UFixed18.wrap(11_291.903496976_577338030e18));
+        // price to purchase ahead of issuance schedule is higher
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(100)), UFixed18.wrap(32_466_151.192919613_034886620e18));
+
+        // after 3 days, expected issuance is 600 tokens, and we've sold 650, slightly ahead of schedule
+        issued = issued + UFixed18Lib.from(450);
+        skip(2 days);
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(100)), UFixed18.wrap(395_518_690.835029055_174152540e18));
+
+        // a day later we're now at 900, when 800 was expected; cost continues to increase
+        issued = issued + UFixed18Lib.from(250);
+        skip(1 days);
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(100)), UFixed18.wrap(4_818_404_062.443085713_321147380e18));
+    }
+
+    function test_toCostEquivalentWithToAmount() public {
+        // equivalent when behind
+        skip(4 days);
+        issued = UFixed18Lib.from(700);
+        UFixed18 amount = UFixed18Lib.from(100);
+        UFixed18 cost = vrgda.toCost(issued, amount);
+        assertApproxEqAbs(UFixed18.unwrap(vrgda.toAmount(issued, cost)), UFixed18.unwrap(amount), 200);
+
+        // equivalent when ahead
+        issued = UFixed18Lib.from(900);
+        cost = vrgda.toCost(issued, UFixed18Lib.from(100));
+        assertApproxEqAbs(UFixed18.unwrap(vrgda.toAmount(issued, cost)), UFixed18.unwrap(amount), 200);
+    }
+
+    function test_recoversAfterPurchaseAtZeroPrice() public {
+        // we're 3 days into the auction, and have only sold 50 tokens; cost to purchase 100 tokens is quite low
+        skip(3 days);
+        issued = UFixed18Lib.from(50);
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(100)), UFixed18.wrap(0.000037011_147859640e18));
+
+        // another day passes, and price for 100 tokens hits zero, but 500 tokens has some cost
+        skip(3 days);
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(100)), UFixed18.wrap(0));
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(500)), UFixed18.wrap(1_691702110));
+        // user grabs 100 tokens for free
+        issued = issued + UFixed18Lib.from(100);
+
+        // we're 6 days in, and should have sold 1200 tokens; price recovers upon doing so
+        assertUFixed18Eq(vrgda.toCost(issued, UFixed18Lib.from(1050)), UFixed18.wrap(220_239.165828664_098470190e18));
+    }
+
+    /// @dev Ensures that users may not use split purchases into smaller batches to reduce cost
+    /// @param daysIn The number of days to skip ahead
+    /// @param alreadyIssued Determines if we are ahead or behind the issuance schedule
+    /// @param tokensToPurchase The number of tokens in each of the small purchases
+    function test_doesNotUnderchargeForSmallPurchases(
+        uint256 daysIn,
+        uint256 alreadyIssued,
+        uint256 tokensToPurchase
+    ) public {
+        daysIn = bound(daysIn, 0, 7);                                          // start-of-auction to a week out
+        alreadyIssued = bound(alreadyIssued, 0, daysIn * 300);                 // bound issuance from 0 to 1.5x expected
+        uint256 numPurchases = 1_000;                                          // gas and memory limited, max ~80k
+        tokensToPurchase = bound(tokensToPurchase, 1e10, 1e18 / numPurchases); // in each purchase, max 1 whole token
+
+        // set up initial state to be ahead or behind the issuance schedule, even with only 1k purchases
+        skip(daysIn * 3600 * 24);
+        issued = UFixed18Lib.from(alreadyIssued);
+
+        // record cost to purchase tokens
+        UFixed18 singlePurchase = vrgda.toCost(issued, UFixed18.wrap(tokensToPurchase * numPurchases));
+
+        // make multiple purchases
+        UFixed18 multiplePurchases = UFixed18Lib.ZERO;
+        for (uint256 i = 0; i < numPurchases; i++) {
+            issued = issued + UFixed18.wrap(tokensToPurchase);
+            multiplePurchases = multiplePurchases + vrgda.toCost(issued, UFixed18.wrap(tokensToPurchase));
+        }
+        assertEq(UFixed18.unwrap(issued), (alreadyIssued * 1e18) + (tokensToPurchase * numPurchases), "total issued mismatch");
+        int256 difference = int256(UFixed18.unwrap(singlePurchase)) - int256(UFixed18.unwrap(multiplePurchases));
+        assertTrue(singlePurchase <= multiplePurchases || difference < 1e18, "undercharges for small purchase");
+    }
+}
diff --git a/test/vrgda/VRGDAMath.t.sol b/test/vrgda/VRGDAMath.t.sol
new file mode 100644
index 0000000..e65f760
--- /dev/null
+++ b/test/vrgda/VRGDAMath.t.sol
@@ -0,0 +1,376 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.25 <0.9.0;
+
+import { UFixed18 } from "../../src/number/types/UFixed18.sol";
+import { VRGDADecayMath } from "../../src/vrgda/VRGDADecayMath.sol";
+import { VRGDAIssuanceMath } from "../../src/vrgda/VRGDAIssuanceMath.sol";
+import { RootTest } from "../RootTest.sol";
+
+contract VRGDAMathTest is RootTest {
+    function setUp() public virtual {
+        vm.warp(1728000000); // time() -> 20_000 (days)
+    }
+
+    function test_time() external {
+        assertUFixed18Eq(VRGDADecayMath.time(), UFixed18.wrap(20_000e18), "value mismatch");
+        skip(1);
+        assertUFixed18Eq(VRGDADecayMath.time(), UFixed18.wrap(20_000_000011574074074074), "value mismatch");
+        skip(86399);
+        assertUFixed18Eq(VRGDADecayMath.time(), UFixed18.wrap(20_001e18), "value mismatch");
+    }
+
+    function test_exponentialDecay_fromto() external {
+        skip(8640 * 2); // 0.2 days
+        // timestamp = 20_000, lamba = 10, k = 100, T = 0.1 -> 0.15
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecay(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0.05e18),
+                UFixed18.wrap(0.1e18)
+            ),
+            UFixed18.wrap(1.447492810230124920e18),
+            "incorrect result with from and to in past"
+        );
+        // timestamp = 20_000, lamba = 10, k = 100, T = 0 -> 0.1
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecay(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0.1e18),
+                UFixed18.wrap(0.2e18)
+            ),
+            UFixed18.wrap(6.321205588285576790e18),
+            "incorrect result with from in past and zero to"
+        );
+        // timestamp = 20_000, lamba = 10, k = 100, T = -0.1 -> 0
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecay(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0.2e18),
+                UFixed18.wrap(0.3e18)
+            ),
+            UFixed18.wrap(17.182818284590452340e18),
+            "incorrect result with zero from and to in future"
+        );
+        // timestamp = 20_000, lamba = 10, k = 100, T = -0.15 -> -0.1
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecay(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0.3e18),
+                UFixed18.wrap(0.35e18)
+            ),
+            UFixed18.wrap(17.634072418790195840e18),
+            "incorrect result with from and to in future"
+        );
+    }
+
+    function test_exponentialDecay_decay() external view {
+        // timestamp = 20_000, lamba = 1, k = 100, T = -0.1 -> 0
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecay(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(1e18),
+                UFixed18.wrap(0e18),
+                UFixed18.wrap(0.1e18)
+            ),
+            UFixed18.wrap(10.517091807564762400e18),
+            "incorrect result with lower decay"
+        );
+        // timestamp = 20_000, lamba = 100, k = 100, T = -0.1 -> 0
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecay(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(0e18),
+                UFixed18.wrap(0.1e18)
+            ),
+            UFixed18.wrap(22025.465794806716461725e18),
+            "incorrect result with higher decay"
+        );
+    }
+
+    function test_exponentialDecay_price() external view {
+        // timestamp = 20_000, lamba = 10, k = 10, T = -0.1 -> 0
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecay(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0e18),
+                UFixed18.wrap(0.1e18)
+            ),
+            UFixed18.wrap(1.718281828459045234e18),
+            "incorrect result with lower initial price"
+        );
+        // timestamp = 20_000, lamba = 10, k = 1000, T = -0.1 -> 0
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecay(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(1000e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0e18),
+                UFixed18.wrap(0.1e18)
+            ),
+            UFixed18.wrap(171.828182845904523400e18),
+            "incorrect result with higher initial price"
+        );
+    }
+
+    // recover if so far behind that small buy would revert
+    function test_exponentialDecay_behind() external {
+        skip(1 days);
+        // timestamp = 20_000, lamba = 10, k = 100
+        // 1 day in, only sold 0.1 day worth of tokens per issuance schedule
+        // cost of purchasing enough to bring us to 0.2 day worth of tokens, still behind by 0.8 day
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecay(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0.1e18),
+                UFixed18.wrap(0.2e18)
+            ),
+            UFixed18.wrap(2120528_238158320), // 0.002120528_238158320
+            "incorrect result while somewhat behind"
+        );
+
+        // 4.5 days in, an attempt to buy a small amount of tokens would result in 0 price
+        skip(3 days + 12 hours);
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecay(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0.2e18),
+                UFixed18.wrap(0.21e18)
+            ),
+            UFixed18.wrap(0),
+            "incorrect result while really behind"
+        );
+
+        // five days in, someone purchases enough tokens to put us slightly ahead of issuance schedule
+        skip(12 hours);
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecay(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0.2e18),
+                UFixed18.wrap(5.4e18)
+            ),
+            UFixed18.wrap(545.981500331_442390190e18), // 545.981500331_442390190
+            "incorrect result after recovering"
+        );
+    }
+
+    function test_exponentialDecay_fuzz(UFixed18 price, UFixed18 decay, UFixed18 from, UFixed18 to) external {
+        skip(86400 * 10); // 10 days
+        decay = boundUFixed18(decay, UFixed18.wrap(1e12), UFixed18.wrap(8e18));
+        price = boundUFixed18(price, UFixed18.wrap(1e12), UFixed18.wrap(1e24));
+        from = boundUFixed18(from, UFixed18.wrap(1e12), UFixed18.wrap(20e18));
+        to = boundUFixed18(to, from, UFixed18.wrap(20e18));
+        UFixed18 cost = VRGDADecayMath.exponentialDecay(UFixed18.wrap(20_000e18), price, decay, from, to); // not revert
+        if (cost < UFixed18.wrap(1e18)) return; // skip under minimum purchase amount
+        UFixed18 to2 = VRGDADecayMath.exponentialDecayI(UFixed18.wrap(20_000e18), price, decay, from, cost); // not revert
+        assertApproxEqRel(UFixed18.unwrap(to), UFixed18.unwrap(to2), 1e13, "result too far off");
+    }
+
+    function test_exponentialDecayI_fromto() external {
+        skip(8640 * 2); // 0.2 days
+        // timestamp = 20_000, lamba = 10, k = 100, T = 0.1 -> 0.15
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecayI(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0.05e18),
+                UFixed18.wrap(1.447492810230124920e18)
+            ),
+            UFixed18.wrap(0.1e18 + 1), // rounding error size (+1)
+            "incorrect result with from and to in past"
+        );
+        // timestamp = 20_000, lamba = 10, k = 100, T = 0 -> 0.1
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecayI(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0.1e18),
+                UFixed18.wrap(6.321205588285576790e18)
+            ),
+            UFixed18.wrap(0.2e18),
+            "incorrect result with from in past and zero to"
+        );
+        // timestamp = 20_000, lamba = 10, k = 100, T = -0.1 -> 0
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecayI(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0.2e18),
+                UFixed18.wrap(17.182818284590452340e18)
+            ),
+            UFixed18.wrap(0.3e18 - 1), // rounding error size (-1)
+            "incorrect result with zero from and to in future"
+        );
+        // timestamp = 20_000, lamba = 10, k = 100, T = -0.15 -> -0.1
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecayI(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0.3e18),
+                UFixed18.wrap(17.634072418790195840e18)
+            ),
+            UFixed18.wrap(0.35e18 - 1), // rounding error size (-1)
+            "incorrect result with from and to in future"
+        );
+    }
+
+    function test_exponentialDecayI_decay() external view {
+        // timestamp = 20_000, lamba = 1, k = 100, T = -0.1 -> 0
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecayI(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(1e18),
+                UFixed18.wrap(0e18),
+                UFixed18.wrap(10.517091807564762400e18)
+            ),
+            UFixed18.wrap(0.1e18 - 11), // rounding error size (-11)
+            "incorrect result with lower decay"
+        );
+        // timestamp = 20_000, lamba = 100, k = 100, T = -0.1 -> 0
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecayI(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(100e18),
+                UFixed18.wrap(0e18),
+                UFixed18.wrap(22025.465794806716461725e18)
+            ),
+            UFixed18.wrap(0.1e18 - 1), // rounding error size (-1)
+            "incorrect result with higher decay"
+        );
+    }
+
+    function test_exponentialDecayI_price() external view {
+        // timestamp = 20_000, lamba = 10, k = 10, T = -0.1 -> 0
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecayI(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0e18),
+                UFixed18.wrap(1.718281828459045234e18)
+            ),
+            UFixed18.wrap(0.1e18 - 1), // rounding error size (-1)
+            "incorrect result with lower initial price"
+        );
+        // timestamp = 20_000, lamba = 10, k = 1000, T = -0.1 -> 0
+        assertUFixed18Eq(
+            VRGDADecayMath.exponentialDecayI(
+                UFixed18.wrap(20_000e18),
+                UFixed18.wrap(1000e18),
+                UFixed18.wrap(10e18),
+                UFixed18.wrap(0e18),
+                UFixed18.wrap(171.828182845904523400e18)
+            ),
+            UFixed18.wrap(0.1e18 - 1), // rounding error size (-1)
+            "incorrect result with higher initial price"
+        );
+    }
+
+    function test_linearIssuance_emission() external pure {
+        // emission = 100_000, auction = 2
+        assertUFixed18Eq(
+           VRGDAIssuanceMath.linearIssuance(
+                UFixed18.wrap(100_000e18),
+                UFixed18.wrap(2e18)
+            ),
+            UFixed18.wrap(200_000e18),
+            "incorrect result with higher emission"
+        );
+        // emission = 1_000, auction = 2
+        assertUFixed18Eq(
+            VRGDAIssuanceMath.linearIssuance(
+                UFixed18.wrap(1_000e18),
+                UFixed18.wrap(2e18)
+            ),
+            UFixed18.wrap(2_000e18),
+            "incorrect result with lower emission"
+        );
+    }
+
+    function test_linearIssuance_auction() external pure {
+        // emission = 10_000, auction = 0.2
+        assertUFixed18Eq(
+           VRGDAIssuanceMath.linearIssuance(
+                UFixed18.wrap(10_000e18),
+                UFixed18.wrap(0.2e18)
+            ),
+            UFixed18.wrap(2_000e18),
+            "incorrect result with earlier auction time"
+        );
+        // emission = 10_000, auction = 20
+        assertUFixed18Eq(
+            VRGDAIssuanceMath.linearIssuance(
+                UFixed18.wrap(10_000e18),
+                UFixed18.wrap(20e18)
+            ),
+            UFixed18.wrap(200_000e18),
+            "incorrect result with later auction time"
+        );
+    }
+
+    function test_linearIssuanceI_emission() external pure {
+        // emission = 1_000, issued = 20_000
+        assertUFixed18Eq(
+            VRGDAIssuanceMath.linearIssuanceI(
+                UFixed18.wrap(1_000e18),
+                UFixed18.wrap(20_000e18)
+            ),
+            UFixed18.wrap(20e18),
+            "incorrect result with lower emission"
+        );
+        // emission = 100_000, issued = 20_000
+        assertUFixed18Eq(
+           VRGDAIssuanceMath.linearIssuanceI(
+                UFixed18.wrap(100_000e18),
+                UFixed18.wrap(20_000e18)
+            ),
+            UFixed18.wrap(0.2e18),
+            "incorrect result with higher emission"
+        );
+    }
+
+    function test_linearIssuanceI_issued() external pure {
+        // emission = 10_000, issued = 2_000
+        assertUFixed18Eq(
+            VRGDAIssuanceMath.linearIssuanceI(
+                UFixed18.wrap(10_000e18),
+                UFixed18.wrap(2_000e18)
+            ),
+            UFixed18.wrap(0.2e18),
+            "incorrect result with lower issued"
+        );
+        // emission = 10_000, issued = 200_000
+        assertUFixed18Eq(
+           VRGDAIssuanceMath.linearIssuanceI(
+                UFixed18.wrap(10_000e18),
+                UFixed18.wrap(200_000e18)
+            ),
+            UFixed18.wrap(20e18),
+            "incorrect result with higher issued"
+        );
+    }
+}


Reviews:
user: login: EdNoepel
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-15T20:42:49Z
user: login: kbrizzle
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-16T00:36:43Z
user: login: EdNoepel
body: Having spent considerable time testing, I am comfortable with this.
state: APPROVED
author_association: CONTRIBUTOR
submitted_at: 2025-05-21T01:12:15Z
user: login: prateekdefi
body: LGTM
state: APPROVED
author_association: CONTRIBUTOR
submitted_at: 2025-05-21T17:05:13Z

Review comments:
diff_hunk: @@ -12,6 +12,7 @@ type Fixed18 is int256;
 using Fixed18Lib for Fixed18 global;
 
 using {
+    neg as -,
path: src/number/types/Fixed18.sol
user: login: EdNoepel
body: Surprised unary minus doesn't conflict with the subtraction overload, but it works.
created_at: 2025-05-15T20:42:49Z
author_association: CONTRIBUTOR
diff_hunk: @@ -12,6 +12,7 @@ type Fixed18 is int256;
 using Fixed18Lib for Fixed18 global;
 
 using {
+    neg as -,
path: src/number/types/Fixed18.sol
user: login: kbrizzle
body: Yeah it's actually supported feature, but quite hidden: https://soliditylang.org/blog/2023/02/22/user-defined-operators/.

![image](https://github.com/user-attachments/assets/62c470d6-2548-46fd-b5ed-cbcd84db3e39)


created_at: 2025-05-16T00:36:43Z
author_association: CONTRIBUTOR

PR comments:
user: login: github-actions[bot]
created_at: 2025-05-12T06:31:38Z
body: # Slither report
  <details><summary>Static Analysis Report</summary>**THIS CHECKLIST IS NOT COMPLETE**. Use `--show-ignored-findings` to show all the results.
Summary
 - [locked-ether](#locked-ether) (1 results) (Medium)
 - [reentrancy-no-eth](#reentrancy-no-eth) (2 results) (Medium)
 - [unused-return](#unused-return) (8 results) (Medium)
 - [incorrect-modifier](#incorrect-modifier) (1 results) (Low)
 - [calls-loop](#calls-loop) (2 results) (Low)
 - [reentrancy-benign](#reentrancy-benign) (6 results) (Low)
 - [reentrancy-events](#reentrancy-events) (7 results) (Low)
 - [dead-code](#dead-code) (49 results) (Informational)
 - [solc-version](#solc-version) (3 results) (Informational)
 - [incorrect-using-for](#incorrect-using-for) (1 results) (Informational)
 - [missing-inheritance](#missing-inheritance) (2 results) (Informational)
 - [naming-convention](#naming-convention) (18 results) (Informational)
 - [too-many-digits](#too-many-digits) (1 results) (Informational)
 - [unimplemented-functions](#unimplemented-functions) (6 results) (Informational)
## locked-ether
Impact: Medium
Confidence: High
 - [ ] ID-0
Contract locking ether found:
	Contract [MutablePauseTarget](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L132-L137) has payable functions:
	 - [MutablePauseTarget.fallback()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L133-L135)
	But does not have a function to withdraw the ether

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L132-L137


## reentrancy-no-eth
Impact: Medium
Confidence: Medium
 - [ ] ID-1
Reentrancy in [Mutable._upgrade(IImplementation,bytes)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L94-L107):
	External calls:
	- [ERC1967Utils.upgradeToAndCall(address(newImplementation),abi.encodeCall(IImplementation.construct,(data)))](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L103)
	State variables written after the call(s):
	- [Mutable$().version = newImplementation.version()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L106)
		- [$ = MutableStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L36)
	[Mutable.MutableStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L31) can be used in cross function reentrancies:
	- [Mutable.Mutable$()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L34-L38)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L94-L107


 - [ ] ID-2
Reentrancy in [Mutable._unpause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L117-L121):
	External calls:
	- [ERC1967Utils.upgradeToAndCall(Mutable$().paused,)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L118)
	State variables written after the call(s):
	- [Mutable$().paused = address(0)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L119)
		- [$ = MutableStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L36)
	[Mutable.MutableStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L31) can be used in cross function reentrancies:
	- [Mutable.Mutable$()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L34-L38)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L117-L121


## unused-return
Impact: Medium
Confidence: Medium
 - [ ] ID-3
[Token6Lib.approve(Token6,address)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token6.sol#L43-L45) ignores return value by [IERC20(Token6.unwrap(self)).approve(grantee,type()(uint256).max)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token6.sol#L44)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token6.sol#L43-L45


 - [ ] ID-4
[TokenLib.approve(Token,address,uint256)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token.sol#L51-L53) ignores return value by [IERC20(Token.unwrap(self)).approve(grantee,amount)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token.sol#L52)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token.sol#L51-L53


 - [ ] ID-5
[Token18Lib.approve(Token18,address,UFixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token18.sol#L53-L55) ignores return value by [IERC20(Token18.unwrap(self)).approve(grantee,UFixed18.unwrap(amount))](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token18.sol#L54)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token18.sol#L53-L55


 - [ ] ID-6
[Token6Lib.approve(Token6,address,UFixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token6.sol#L54-L56) ignores return value by [IERC20(Token6.unwrap(self)).approve(grantee,UFixed6.unwrap(amount))](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token6.sol#L55)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token6.sol#L54-L56


 - [ ] ID-7
[Airdrop.addDistributions(Token18,bytes32)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/distribution/Airdrop.sol#L25-L31) ignores return value by [_merkleRoots.add(merkleRoot)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/distribution/Airdrop.sol#L28)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/distribution/Airdrop.sol#L25-L31


 - [ ] ID-8
[Mutator.create(IImplementation,bytes)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L34-L40) ignores return value by [_mutables.add(address(newMutable = new Mutable(implementation,data)))](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L38)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L34-L40


 - [ ] ID-9
[TokenLib.approve(Token,address)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token.sol#L40-L42) ignores return value by [IERC20(Token.unwrap(self)).approve(grantee,type()(uint256).max)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token.sol#L41)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token.sol#L40-L42


 - [ ] ID-10
[Token18Lib.approve(Token18,address)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token18.sol#L43-L45) ignores return value by [IERC20(Token18.unwrap(self)).approve(grantee,type()(uint256).max)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token18.sol#L44)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token18.sol#L43-L45


## incorrect-modifier
Impact: Low
Confidence: High
 - [ ] ID-11
Modifier [Attribute.initializer(string)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Attribute.sol#L28-L32) does not always execute _; or revert

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Attribute.sol#L28-L32


## calls-loop
Impact: Low
Confidence: Medium
 - [ ] ID-12
[Mutator._pause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L51-L54) has external calls inside a loop: [IMutable(_mutables.at(i)).pause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L52)
	Calls stack containing the loop:
		Pausable.pause()

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L51-L54


 - [ ] ID-13
[Mutator._unpause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L56-L59) has external calls inside a loop: [IMutable(_mutables.at(i)).unpause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L57)
	Calls stack containing the loop:
		Pausable.unpause()

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L56-L59


## reentrancy-benign
Impact: Low
Confidence: Medium
 - [ ] ID-14
Reentrancy in [Factory._create(bytes)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L53-L56):
	External calls:
	- [newInstance = IInstance(address(new BeaconProxy(address(this),data)))](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L54)
	State variables written after the call(s):
	- [_register(newInstance)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L55)
		- [$ = FactoryStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L29)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L53-L56


 - [ ] ID-15
Reentrancy in [VerifierBase.cancelGroupWithSignature(GroupCancellation,bytes)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/verifier/VerifierBase.sol#L55-L58):
	External calls:
	- [IVerifierBase(this).verifyGroupCancellation(groupCancellation,signature)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/verifier/VerifierBase.sol#L56)
	State variables written after the call(s):
	- [_cancelGroup(groupCancellation.common.account,groupCancellation.group)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/verifier/VerifierBase.sol#L57)
		- [groups[account][group] = true](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/verifier/VerifierBase.sol#L80)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/verifier/VerifierBase.sol#L55-L58


 - [ ] ID-16
Reentrancy in [Mutator.create(IImplementation,bytes)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L34-L40):
	External calls:
	- [_mutables.add(address(newMutable = new Mutable(implementation,data)))](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L38)
	State variables written after the call(s):
	- [_nameToMutable[ShortStrings.toShortString(implementation.name())] = IMutable(address(newMutable))](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L39)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L34-L40


 - [ ] ID-17
Reentrancy in [Mutator._pause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L51-L54):
	External calls:
	- [IMutable(_mutables.at(i)).pause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L52)
	State variables written after the call(s):
	- [super._pause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L53)
		- [$ = PausableStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Pausable.sol#L28)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L51-L54


 - [ ] ID-18
Reentrancy in [Factory._create2(bytes,bytes32)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L62-L65):
	External calls:
	- [newInstance = IInstance(address(new BeaconProxy(address(this),data)))](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L63)
	State variables written after the call(s):
	- [_register(newInstance)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L64)
		- [$ = FactoryStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L29)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L62-L65


 - [ ] ID-19
Reentrancy in [Mutator._unpause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L56-L59):
	External calls:
	- [IMutable(_mutables.at(i)).unpause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L57)
	State variables written after the call(s):
	- [super._unpause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L58)
		- [$ = PausableStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Pausable.sol#L28)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L56-L59


## reentrancy-events
Impact: Low
Confidence: Medium
 - [ ] ID-20
Reentrancy in [Mutator._pause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L51-L54):
	External calls:
	- [IMutable(_mutables.at(i)).pause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L52)
	Event emitted after the call(s):
	- [Paused()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Pausable.sol#L72)
		- [super._pause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L53)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L51-L54


 - [ ] ID-21
Reentrancy in [Factory._create(bytes)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L53-L56):
	External calls:
	- [newInstance = IInstance(address(new BeaconProxy(address(this),data)))](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L54)
	Event emitted after the call(s):
	- [InstanceRegistered(newInstance)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L84)
		- [_register(newInstance)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L55)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L53-L56


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

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/verifier/VerifierBase.sol#L55-L58


 - [ ] ID-23
Reentrancy in [Mutable._unpause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L117-L121):
	External calls:
	- [ERC1967Utils.upgradeToAndCall(Mutable$().paused,)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L118)
	Event emitted after the call(s):
	- [Unpaused()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L120)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L117-L121


 - [ ] ID-24
Reentrancy in [Mutator._unpause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L56-L59):
	External calls:
	- [IMutable(_mutables.at(i)).unpause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L57)
	Event emitted after the call(s):
	- [Unpaused()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Pausable.sol#L78)
		- [super._unpause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L58)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutator.sol#L56-L59


 - [ ] ID-25
Reentrancy in [Mutable._pause()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L110-L114):
	External calls:
	- [ERC1967Utils.upgradeToAndCall(_pauseTarget,)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L112)
	Event emitted after the call(s):
	- [Paused()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L113)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L110-L114


 - [ ] ID-26
Reentrancy in [Factory._create2(bytes,bytes32)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L62-L65):
	External calls:
	- [newInstance = IInstance(address(new BeaconProxy(address(this),data)))](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L63)
	Event emitted after the call(s):
	- [InstanceRegistered(newInstance)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L84)
		- [_register(newInstance)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L64)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L62-L65


## dead-code
Impact: Informational
Confidence: Medium
 - [ ] ID-27
[eq(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L288-L290) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L288-L290


 - [ ] ID-28
[add(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L295-L297) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L295-L297


 - [ ] ID-29
[Factory._register(IInstance)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L82-L85) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L82-L85


 - [ ] ID-30
[eq(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L295-L297) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L295-L297


 - [ ] ID-31
[neg(Fixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L287-L289) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L287-L289


 - [ ] ID-32
[Implementation._constructing()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L54-L56) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L54-L56


 - [ ] ID-33
[Instance.__Instance__constructor()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Instance.sol#L28-L30) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Instance.sol#L28-L30


 - [ ] ID-34
[add(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L288-L290) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L288-L290


 - [ ] ID-35
[mul(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L311-L313) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L311-L313


 - [ ] ID-36
[eq(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L327-L329) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L327-L329


 - [ ] ID-37
[gt(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L311-L314) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L311-L314


 - [ ] ID-38
[neq(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L335-L337) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L335-L337


 - [ ] ID-39
[mul(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L304-L306) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L304-L306


 - [ ] ID-40
[gt(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L343-L346) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L343-L346


 - [ ] ID-41
[lt(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L313-L316) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L313-L316


 - [ ] ID-42
[div(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L280-L282) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L280-L282


 - [ ] ID-43
[gte(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L329-L331) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L329-L331


 - [ ] ID-44
[neg(Fixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L280-L282) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L280-L282


 - [ ] ID-45
[sub(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L303-L305) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L303-L305


 - [ ] ID-46
[gte(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L361-L363) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L361-L363


 - [ ] ID-47
[mul(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L279-L281) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L279-L281


 - [ ] ID-48
[lte(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L369-L371) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L369-L371


 - [ ] ID-49
[lte(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L330-L332) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L330-L332


 - [ ] ID-50
[mul(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L272-L274) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L272-L274


 - [ ] ID-51
[lt(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L352-L355) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L352-L355


 - [ ] ID-52
[div(Fixed6,Fixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L319-L321) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L319-L321


 - [ ] ID-53
[neq(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L296-L298) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L296-L298


 - [ ] ID-54
[Implementation._deployer()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L59-L61) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L59-L61


 - [ ] ID-55
[div(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L312-L314) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L312-L314


 - [ ] ID-56
[lt(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L320-L323) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L320-L323


 - [ ] ID-57
[lt(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L345-L348) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L345-L348


 - [ ] ID-58
[gt(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L336-L339) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L336-L339


 - [ ] ID-59
[lte(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L362-L364) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L362-L364


 - [ ] ID-60
[eq(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L320-L322) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L320-L322


 - [ ] ID-61
[sub(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L264-L266) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L264-L266


 - [ ] ID-62
[neq(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L303-L305) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L303-L305


 - [ ] ID-63
[gt(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L304-L307) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L304-L307


 - [ ] ID-64
[gte(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L322-L324) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L322-L324


 - [ ] ID-65
[sub(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L271-L273) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L271-L273


 - [ ] ID-66
[Factory._create2(bytes,bytes32)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L62-L65) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L62-L65


 - [ ] ID-67
[add(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L263-L265) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L263-L265


 - [ ] ID-68
[Factory._computeCreate2Address(bytes,bytes32)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L71-L77) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L71-L77


 - [ ] ID-69
[sub(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L296-L298) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L296-L298


 - [ ] ID-70
[gte(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L354-L356) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L354-L356


 - [ ] ID-71
[Factory._create(bytes)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L53-L56) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L53-L56


 - [ ] ID-72
[lte(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L337-L339) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L337-L339


 - [ ] ID-73
[div(UFixed6,UFixed6)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L287-L289) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L287-L289


 - [ ] ID-74
[add(UFixed18,UFixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L256-L258) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L256-L258


 - [ ] ID-75
[neq(Fixed18,Fixed18)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L328-L330) is never used and should be removed

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L328-L330


## solc-version
Impact: Informational
Confidence: High
 - [ ] ID-76
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/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed18.sol#L2)
	- [^0.8.19](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/Fixed6.sol#L2)
	- [^0.8.19](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed6.sol#L2)

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


 - [ ] ID-77
Version constraint >=0.8.20 contains known severe issues (https://solidity.readthedocs.io/en/latest/bugs.html)
	- VerbatimInvalidDeduplication
	- FullInlinerNonExpressionSplitArgumentEvaluationOrder
	- MissingSideEffectsOnSelectorAccess.
It is used by:
	- [>=0.8.20](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/vrgda/VRGDADecayMath.sol#L2)
	- [>=0.8.20](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/vrgda/VRGDAIssuanceMath.sol#L2)
	- [>=0.8.20](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/vrgda/types/LinearExponentialVRGDA.sol#L2)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/vrgda/VRGDADecayMath.sol#L2


 - [ ] ID-78
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/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/access/ProxyOwner.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/accumulator/types/Accumulator6.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/accumulator/types/UAccumulator6.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Attribute.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Instance.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Ownable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/OwnableStub.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/OwnerDelegatable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/OwnerExecutable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/OwnerWithdrawable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Pausable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/interfaces/IFactory.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/interfaces/IInstance.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/interfaces/IOwnable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/interfaces/IPausable.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/distribution/Treasury.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/distribution/interfaces/ITreasury.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Derived.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/interfaces/IAttribute.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/interfaces/IImplementation.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/types/Version.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/NumberMath.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/number/types/UFixed18.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/synbook/types/SynBook6.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token18.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/token/types/Token6.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/utilization/types/JumpRateUtilizationCurve18.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/utilization/types/JumpRateUtilizationCurve6.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/utils/console.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/verifier/VerifierBase.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/verifier/interfaces/IVerifierBase.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/verifier/types/Common.sol#L2)
	- [^0.8.13](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/verifier/types/GroupCancellation.sol#L2)

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


## incorrect-using-for
Impact: Informational
Confidence: High
 - [ ] ID-79
using-for statement at src/mutability/types/Version.sol#5 is incorrect - no matching function for Version found in [VersionLib](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/types/Version.sol#L16-L20).

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/types/Version.sol#L16-L20


## missing-inheritance
Impact: Informational
Confidence: High
 - [ ] ID-80
[OwnableStub](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/OwnableStub.sol#L9-L15) should inherit from [Contract](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L6-L13)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/OwnableStub.sol#L9-L15


 - [ ] ID-81
[MutablePauseTarget](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L132-L137) should inherit from [Contract](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L6-L13)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L132-L137


## naming-convention
Impact: Informational
Confidence: High
 - [ ] ID-82
Function [Pausable.__Pausable__constructor()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Pausable.sol#L34-L36) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Pausable.sol#L34-L36


 - [ ] ID-83
Function [Mutable.Mutable$()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L34-L38) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L34-L38


 - [ ] ID-84
Function [Instance.__Instance__constructor()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Instance.sol#L28-L30) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Instance.sol#L28-L30


 - [ ] ID-85
Constant [Mutable.MutableStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L31) is not in UPPER_CASE_WITH_UNDERSCORES

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Mutable.sol#L31


 - [ ] ID-86
Constant [Instance.InstanceStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Instance.sol#L18) is not in UPPER_CASE_WITH_UNDERSCORES

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Instance.sol#L18


 - [ ] ID-87
Constant [Ownable.OwnableStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Ownable.sol#L21) is not in UPPER_CASE_WITH_UNDERSCORES

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Ownable.sol#L21


 - [ ] ID-88
Function [Ownable.__Ownable__constructor()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Ownable.sol#L42-L44) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Ownable.sol#L42-L44


 - [ ] ID-89
Function [Factory.Factory$()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L27-L31) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L27-L31


 - [ ] ID-90
Constant [Implementation.ImplementationStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L19) is not in UPPER_CASE_WITH_UNDERSCORES

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L19


 - [ ] ID-91
Function [Ownable.Ownable$()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Ownable.sol#L24-L28) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Ownable.sol#L24-L28


 - [ ] ID-92
Function [Implementation.Implementation$()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L22-L26) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L22-L26


 - [ ] ID-93
Constant [Pausable.PausableStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Pausable.sol#L23) is not in UPPER_CASE_WITH_UNDERSCORES

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Pausable.sol#L23


 - [ ] ID-94
Function [Pausable.Pausable$()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Pausable.sol#L26-L30) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Pausable.sol#L26-L30


 - [ ] ID-95
Function [Implementation.__constructor(bytes)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L64) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L64


 - [ ] ID-96
Function [Instance.Instance$()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Instance.sol#L21-L25) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Instance.sol#L21-L25


 - [ ] ID-97
Constant [Factory.FactoryStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L24) is not in UPPER_CASE_WITH_UNDERSCORES

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L24


 - [ ] ID-98
Function [Attribute.Attribute$()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Attribute.sol#L20-L24) is not in mixedCase

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Attribute.sol#L20-L24


 - [ ] ID-99
Constant [Attribute.AttributeStorageLocation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Attribute.sol#L17) is not in UPPER_CASE_WITH_UNDERSCORES

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Attribute.sol#L17


## too-many-digits
Impact: Informational
Confidence: Medium
 - [ ] ID-100
[Factory._computeCreate2Address(bytes,bytes32)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L71-L77) uses literals with too many digits:
	- [bytecode = abi.encodePacked(type()(BeaconProxy).creationCode,abi.encode(address(this),data))](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L72-L75)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L71-L77


## unimplemented-functions
Impact: Informational
Confidence: High
 - [ ] ID-101
[Factory](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L16-L92) does not implement functions:
	- [Contract._constructing()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L8)
	- [Contract._deployer()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L11)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Factory.sol#L16-L92


 - [ ] ID-102
[OwnerExecutable](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/OwnerExecutable.sol#L10-L19) does not implement functions:
	- [Contract._constructing()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L8)
	- [Contract._deployer()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L11)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/OwnerExecutable.sol#L10-L19


 - [ ] ID-103
[Instance](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Instance.sol#L10-L54) does not implement functions:
	- [Contract._constructing()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L8)
	- [Contract._deployer()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L11)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/Instance.sol#L10-L54


 - [ ] ID-104
[OwnerWithdrawable](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/OwnerWithdrawable.sol#L9-L16) does not implement functions:
	- [Contract._constructing()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L8)
	- [Contract._deployer()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L11)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/OwnerWithdrawable.sol#L9-L16


 - [ ] ID-105
[OwnerDelegatable](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/OwnerDelegatable.sol#L10-L18) does not implement functions:
	- [Contract._constructing()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L8)
	- [Contract._deployer()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Contract.sol#L11)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/attribute/OwnerDelegatable.sol#L10-L18


 - [ ] ID-106
[Implementation](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L11-L65) does not implement functions:
	- [Implementation.__constructor(bytes)](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L64)
	- [Implementation.name()](https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L41)

https://github.com/equilibria-xyz/root/blob/77fbf3730472c0036f8b21fb4b5818e6283826f0/src/mutability/Implementation.sol#L11-L65


</details>
  <br/>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-20T20:00:49Z
body: <h2>Unit Test Coverage Report</h2>Coverage after merging <b>britz-vrgda</b> into <b>v3</b> will be<table><tbody><tr><th>86.91%</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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/attribute/Attribute.sol'>Attribute.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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/distribution</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/distribution/Airdrop.sol'>Airdrop.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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/distribution/Treasury.sol'>Treasury.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/mutability</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/mutability/Derived.sol'>Derived.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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/mutability/Implementation.sol'>Implementation.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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/mutability/Mutable.sol'>Mutable.sol</a></td><td><b>97.10%</b></td><td><b>84.62%</b></td><td>100%</td><td>100%</td><td><a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/mutability/Mutable.sol#L100'>100</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/mutability/Mutable.sol#L54'>54</a></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/mutability/Mutator.sol'>Mutator.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/mutability/types</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/mutability/types/Version.sol'>Version.sol</a></td><td><b>50%</b></td><td>100%</td><td><b>50%</b></td><td><b>50%</b></td><td><a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/mutability/types/Version.sol#L17-L18'>17&ndash;18</a></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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/NumberMath.sol'>NumberMath.sol</a></td><td><b>50%</b></td><td><b>50%</b></td><td><b>50%</b></td><td><b>50%</b></td><td><a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/NumberMath.sol#L18-L19'>18&ndash;19</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/NumberMath.sol#L19-L20'>19&ndash;20</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/NumberMath.sol#L27-L28'>27&ndash;28</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/NumberMath.sol#L37-L40'>37&ndash;40</a></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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol'>Fixed18.sol</a></td><td><b>50%</b></td><td><b>50%</b></td><td><b>50%</b></td><td><b>50%</b></td><td><a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L101-L102'>101&ndash;102</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L109-L110'>109&ndash;110</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L118-L119'>118&ndash;119</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L119'>119</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L119-L122'>119&ndash;122</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L124'>124</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L133-L134'>133&ndash;134</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L134'>134</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L134-L137'>134&ndash;137</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L139'>139</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L148-L149'>148&ndash;149</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L157-L158'>157&ndash;158</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L166-L167'>166&ndash;167</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L175-L176'>175&ndash;176</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L186-L190'>186&ndash;190</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L197-L198'>197&ndash;198</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L205-L206'>205&ndash;206</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L213-L214'>213&ndash;214</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L220-L221'>220&ndash;221</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L230'>230</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L232-L233'>232&ndash;233</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L240-L241'>240&ndash;241</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L249-L250'>249&ndash;250</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L258-L259'>258&ndash;259</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L265-L266'>265&ndash;266</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L272-L273'>272&ndash;273</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L45-L47'>45&ndash;47</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L47-L48'>47&ndash;48</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L55-L57'>55&ndash;57</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L57'>57</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L61'>61</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L63'>63</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L69-L70'>69&ndash;70</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L76-L77'>76&ndash;77</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L84-L85'>84&ndash;85</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed18.sol#L93-L94'>93&ndash;94</a></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol'>Fixed6.sol</a></td><td><b>50%</b></td><td><b>50%</b></td><td><b>50%</b></td><td><b>50%</b></td><td><a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L100-L101'>100&ndash;101</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L108-L109'>108&ndash;109</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L116-L117'>116&ndash;117</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L125-L126'>125&ndash;126</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L126'>126</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L126-L129'>126&ndash;129</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L131'>131</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L140-L141'>140&ndash;141</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L141'>141</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L141-L144'>141&ndash;144</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L146'>146</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L155-L156'>155&ndash;156</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L164-L165'>164&ndash;165</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L173-L174'>173&ndash;174</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L182-L183'>182&ndash;183</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L193-L197'>193&ndash;197</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L204-L205'>204&ndash;205</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L212-L213'>212&ndash;213</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L220-L221'>220&ndash;221</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L227-L228'>227&ndash;228</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L237'>237</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L239-L240'>239&ndash;240</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L247-L248'>247&ndash;248</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L256-L257'>256&ndash;257</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L265-L266'>265&ndash;266</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L272-L273'>272&ndash;273</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L279-L280'>279&ndash;280</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L44-L46'>44&ndash;46</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L46-L47'>46&ndash;47</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L54-L56'>54&ndash;56</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L56'>56</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L60'>60</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L62'>62</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L68-L69'>68&ndash;69</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L75-L76'>75&ndash;76</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L83-L84'>83&ndash;84</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/Fixed6.sol#L91-L92'>91&ndash;92</a></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol'>UFixed18.sol</a></td><td><b>50%</b></td><td><b>50%</b></td><td><b>50%</b></td><td><b>50%</b></td><td><a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L100'>100</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L107-L108'>107&ndash;108</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L116-L117'>116&ndash;117</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L117'>117</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L117-L118'>117&ndash;118</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L120'>120</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L129-L130'>129&ndash;130</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L130'>130</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L130-L131'>130&ndash;131</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L133'>133</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L142-L143'>142&ndash;143</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L151-L152'>151&ndash;152</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L161-L162'>161&ndash;162</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L170-L171'>170&ndash;171</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L181-L185'>181&ndash;185</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L192-L193'>192&ndash;193</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L200-L201'>200&ndash;201</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L208-L209'>208&ndash;209</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L215-L216'>215&ndash;216</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L224-L225'>224&ndash;225</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L233-L234'>233&ndash;234</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L240-L241'>240&ndash;241</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L247-L248'>247&ndash;248</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L41-L43'>41&ndash;43</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L43-L44'>43&ndash;44</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L51-L52'>51&ndash;52</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L58-L59'>58&ndash;59</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L65-L66'>65&ndash;66</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L73-L74'>73&ndash;74</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L82-L83'>82&ndash;83</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L91-L92'>91&ndash;92</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed18.sol#L99'>99</a></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol'>UFixed6.sol</a></td><td><b>50%</b></td><td><b>50%</b></td><td><b>50%</b></td><td><b>50%</b></td><td><a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L100'>100</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L107-L108'>107&ndash;108</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L115-L116'>115&ndash;116</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L124-L125'>124&ndash;125</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L125'>125</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L125-L126'>125&ndash;126</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L128'>128</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L137-L138'>137&ndash;138</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L138'>138</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L138-L139'>138&ndash;139</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L141'>141</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L150-L151'>150&ndash;151</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L159-L160'>159&ndash;160</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L168-L169'>168&ndash;169</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L177-L178'>177&ndash;178</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L188-L192'>188&ndash;192</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L199-L200'>199&ndash;200</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L207-L208'>207&ndash;208</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L215-L216'>215&ndash;216</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L222-L223'>222&ndash;223</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L231-L232'>231&ndash;232</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L240-L241'>240&ndash;241</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L247-L248'>247&ndash;248</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L254-L255'>254&ndash;255</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L41-L43'>41&ndash;43</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L43-L44'>43&ndash;44</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L51-L52'>51&ndash;52</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L58-L59'>58&ndash;59</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L65-L66'>65&ndash;66</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L73-L74'>73&ndash;74</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L81-L82'>81&ndash;82</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L90-L91'>90&ndash;91</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/number/types/UFixed6.sol#L99'>99</a></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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token.sol'>Token.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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol'>Token18.sol</a></td><td><b>55.77%</b></td><td><b>50%</b></td><td><b>56.25%</b></td><td><b>56.06%</b></td><td><a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L105-L106'>105&ndash;106</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L112-L113'>112&ndash;113</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L119-L120'>119&ndash;120</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L135-L136'>135&ndash;136</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L144-L145'>144&ndash;145</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L151-L152'>151&ndash;152</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L26-L27'>26&ndash;27</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L34-L35'>34&ndash;35</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L43-L44'>43&ndash;44</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L53-L54'>53&ndash;54</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L60-L61'>60&ndash;61</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L77-L78'>77&ndash;78</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L87-L88'>87&ndash;88</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L97-L98'>97&ndash;98</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L98'>98</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L98-L99'>98&ndash;99</a>, <a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/token/types/Token18.sol#L99'>99</a></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/types</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/verifier/VerifierBase.sol'>VerifierBase.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/types</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/verifier/types/GroupCancellation.sol'>GroupCancellation.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/vrgda</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/vrgda/VRGDADecayMath.sol'>VRGDADecayMath.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/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/vrgda/VRGDAIssuanceMath.sol'>VRGDAIssuanceMath.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr><tr><td colspan='6'><b>src/vrgda/types</b></td></tr><tr><td>&nbsp; &nbsp;<a href='https://github.com/equilibria-xyz/root/blob/4e11375c1b6d3a9d4e9dd7ce924d61f18ccb0d6d/src/vrgda/types/LinearExponentialVRGDA.sol'>LinearExponentialVRGDA.sol</a></td><td>100%</td><td>100%</td><td>100%</td><td>100%</td><td></td></tr></tbody></table></details>
author_association: NONE