Fix fuzz max long test (#101)

# Resolved Issues
Partially resolves these two:
#88
#45

# Description
The fee rounding behavior was adjusted recently to more closely match
solidity, but the order of operations was not exactly the same. This
caused an occasional slight variation in output (usually off by 1e1),
that compounded in situations where we were iteratively assessing fees
such as `max_long`. In that case, the error would grow to as much as
1e5.

During my effort to find this bug I
- modified some math to use the e.g. `.mul_down` syntax instead of `*`
where it was sufficiently complicated to require this to easily pattern
match against Solidity.
- modified `calculate_max_long` to return errors instead of panic. This
makes checks in the tests ugly, but that is a temporary problem until we
purge the panics all-together
(#20)
- purged the use of `traced` and `trace_test` which is helpful for
debugging but was not actively being used and can slow down tests.

# Review Checklists

Please check each item **before approving** the pull request. While
going
through the checklist, it is recommended to leave comments on items that
are
referenced in the checklist to make sure that they are reviewed.

- [ ] **Testing**
    - [ ] Are there new or updated unit or integration tests?
    - [ ] Do the tests cover the happy paths?
    - [ ] Do the tests cover the unhappy paths?
- [ ] Are there an adequate number of fuzz tests to ensure that we are
          covering the full input space?
- [ ] If matching Solidity behavior, are there differential fuzz tests
that
          ensure that Rust matches Solidity?

bindings/hyperdrivepy/src/hyperdrive_state_methods.rs

@@ -309,9 +309,12 @@ impl HyperdriveState {
         let checkpoint_exposure_i = I256::from_dec_str(checkpoint_exposure).map_err(|_| {
             PyErr::new::<PyValueError, _>("Failed to convert checkpoint_exposure string to I256")
         })?;
-        let result_fp =
-            self.state
-                .calculate_max_long(budget_fp, checkpoint_exposure_i, maybe_max_iterations);
+        let result_fp = self
+            .state
+            .calculate_max_long(budget_fp, checkpoint_exposure_i, maybe_max_iterations)
+            .map_err(|e| {
+                PyErr::new::<PyValueError, _>(format!("Failed to calculate max long: {}", e))
+            })?;
         let result = U256::from(result_fp).to_string();
         Ok(result)
     }

crates/hyperdrive-math/src/lib.rs

@@ -332,7 +332,6 @@ impl YieldSpace for State {
 
 #[cfg(test)]
 mod tests {
-    use eyre::Result;
     use rand::thread_rng;
 
     use super::*;

crates/hyperdrive-math/src/long/fees.rs

@@ -15,8 +15,8 @@ impl State {
     /// $$
     pub fn open_long_curve_fee(&self, base_amount: FixedPoint) -> FixedPoint {
         // NOTE: Round up to overestimate the curve fee.
-        (fixed!(1e18).div_up(self.calculate_spot_price()) - fixed!(1e18))
-            .mul_up(self.curve_fee())
+        self.curve_fee()
+            .mul_up(fixed!(1e18).div_up(self.calculate_spot_price()) - fixed!(1e18))
             .mul_up(base_amount)
     }
 
@@ -38,9 +38,9 @@ impl State {
             None => self.open_long_curve_fee(base_amount),
         };
         // NOTE: Round down to underestimate the governance curve fee.
-        self.calculate_spot_price()
-            .mul_down(curve_fee)
+        curve_fee
             .mul_down(self.governance_lp_fee())
+            .mul_down(self.calculate_spot_price())
     }
 
     /// Calculates the curve fee paid when closing longs for a given bond amount.