actually make test fail

Author: wakamex

crates/hyperdrive-math/src/short/max.rs

@@ -2,6 +2,7 @@ use std::cmp::Ordering;
 
 use ethers::types::I256;
 use fixed_point::FixedPoint;
+use eyre::{eyre, Result};
 use fixed_point_macros::fixed;
 
 use crate::{calculate_effective_share_reserves, State, YieldSpace};
@@ -294,6 +295,7 @@ impl State {
         };
         if self
             .solvency_after_short(absolute_max_bond_amount, spot_price, checkpoint_exposure)
+            .unwrap()
             .is_some()
         {
             return absolute_max_bond_amount;
@@ -316,9 +318,9 @@ impl State {
         //
         // The guess that we make is very important in determining how quickly
         // we converge to the solution.
-        let mut max_bond_amount = self.absolute_max_short_guess(spot_price, checkpoint_exposure);
+        let mut max_bond_amount = self.absolute_max_short_guess(spot_price, checkpoint_exposure).unwrap();
         let mut maybe_solvency =
-            self.solvency_after_short(max_bond_amount, spot_price, checkpoint_exposure);
+            self.solvency_after_short(max_bond_amount, spot_price, checkpoint_exposure).unwrap();
         if maybe_solvency.is_none() {
             panic!("Initial guess in `absolute_max_short` is insolvent.");
         }
@@ -348,7 +350,7 @@ impl State {
                 possible_max_bond_amount,
                 spot_price,
                 checkpoint_exposure,
-            );
+            ).unwrap();
             if let Some(s) = maybe_solvency {
                 solvency = s;
                 max_bond_amount = possible_max_bond_amount;
@@ -387,13 +389,13 @@ impl State {
         &self,
         spot_price: FixedPoint,
         checkpoint_exposure: I256,
-    ) -> FixedPoint {
+    ) -> Result<FixedPoint> {
         let estimate_price = spot_price;
         let checkpoint_exposure =
             FixedPoint::from(checkpoint_exposure.max(I256::zero())) / self.vault_share_price();
-        (self.vault_share_price() * (self.calculate_solvency() + checkpoint_exposure))
+        Ok((self.vault_share_price() * (self.calculate_solvency() + checkpoint_exposure))
             / (estimate_price - self.curve_fee() * (fixed!(1e18) - spot_price)
-                + self.governance_lp_fee() * self.curve_fee() * (fixed!(1e18) - spot_price))
+                + self.governance_lp_fee() * self.curve_fee() * (fixed!(1e18) - spot_price)))
     }
 
     /// Calculates the pool's solvency after opening a short.
@@ -432,11 +434,11 @@ impl State {
         bond_amount: FixedPoint,
         spot_price: FixedPoint,
         checkpoint_exposure: I256,
-    ) -> Option<FixedPoint> {
+    ) -> Result<Option<FixedPoint>> {
         let principal = if let Ok(p) = self.calculate_short_principal(bond_amount) {
             p
         } else {
-            return None;
+            return Ok(None);
         };
         let share_reserves = self.share_reserves()
             - (principal
@@ -449,12 +451,15 @@ impl State {
         //         / self.vault_share_price();
         let exposure = {
             let checkpoint_exposure: FixedPoint = checkpoint_exposure.max(I256::zero()).into();
+            if self.long_exposure() <= checkpoint_exposure {
+                return Err(eyre!("InsufficientLongExposure",));
+            }
             (self.long_exposure() - checkpoint_exposure) / self.vault_share_price()
         };
         if share_reserves >= exposure + self.minimum_share_reserves() {
-            Some(share_reserves - exposure - self.minimum_share_reserves())
+            Ok(Some(share_reserves - exposure - self.minimum_share_reserves()))
         } else {
-            None
+            Ok(None)
         }
     }
 
@@ -519,11 +524,24 @@ mod tests {
     #[tokio::test]
     async fn fuzz_calculate_max_short_no_budget() -> Result<()> {
         let chain = TestChain::new().await?;
+        let mut lowest_rate: Option<FixedPoint> = None;
+        let mut highest_rate: Option<FixedPoint> = None;
+
+        let mut passed_tests = 0;
+        let mut failed_tests = 0;
 
         // Fuzz the rust and solidity implementations against each other.
         let mut rng = thread_rng();
         for _ in 0..*FAST_FUZZ_RUNS {
             let state = rng.gen::<State>();
+            let fixed_rate = state.calculate_spot_rate();
+            if lowest_rate.is_none() || fixed_rate < lowest_rate.unwrap() {
+                lowest_rate = Some(fixed_rate);
+            }
+            if highest_rate.is_none() || fixed_rate > highest_rate.unwrap() {
+                highest_rate = Some(fixed_rate);
+            }
+            println!("Fixed rate: {}", fixed_rate);
             let checkpoint_exposure = {
                 let value = rng.gen_range(fixed!(0)..=fixed!(10_000_000e18));
                 if rng.gen() {
@@ -567,10 +585,18 @@ mod tests {
                 .await
             {
                 Ok(expected) => {
+                    passed_tests += 1;
                     assert_eq!(actual.unwrap(), FixedPoint::from(expected));
                 }
-                Err(_) => assert!(actual.is_err()),
-            }
+                Err(expected) => {
+                    failed_tests += 1;
+                    println!("Test failed: actual: {:?} expected: {:?}", actual, expected);
+                    assert!(actual.is_err());
+                }
+            }  // end for loop
+            let total_tests = failed_tests + passed_tests;
+            let failure_rate = failed_tests as f64 / total_tests as f64;
+            println!("Total tests: {} Passed: {} Failed: {}, Failure rate: {}", total_tests, passed_tests, failed_tests, failure_rate);
         }
 
         Ok(())
@@ -596,7 +622,6 @@ mod tests {
 
             // Fund Alice and Bob.
             let fixed_rate = rng.gen_range(fixed!(0.01e18)..=fixed!(1e18));
-            println!("Fixed rate: {}", fixed_rate);
             let contribution = rng.gen_range(fixed!(100_000e18)..=fixed!(100_000_000e18));
             alice.fund(contribution).await?;
 

crates/test-utils/src/chain/deploy.rs

@@ -279,9 +279,9 @@ impl Chain {
             sweep_collector: client.address(),
             governance: client.address(),
             fees: Fees {
-                curve: uint256!(0.05e18),
-                flat: uint256!(0.0005e18),
-                governance_lp: uint256!(0.15e18),
+                curve: uint256!(0.01e18),
+                flat: uint256!(0e18),
+                governance_lp: uint256!(0.1e18),
                 governance_zombie: uint256!(0.15e18),
             },
         };