improving name, address tests to step size rounded base_asset_amount_long/short

0xbigz · 0xbigz · commit f33f49b8bf8b · 2024-02-19T17:13:27.000-05:00
diff --git a/programs/drift/src/controller/lp/tests.rs b/programs/drift/src/controller/lp/tests.rs
@@ -225,7 +225,7 @@ fn test_remainder_long_settle_too_large_order_step_size() {
     market.amm.base_asset_amount_per_lp = 10;
     market.amm.quote_asset_amount_per_lp = -10;
     market.amm.base_asset_amount_with_unsettled_lp = -10;
-    market.amm.base_asset_amount_short = -10;
+    market.amm.base_asset_amount_with_amm = 10;
 
     settle_lp_position(&mut position, &mut market).unwrap();
 
@@ -235,11 +235,8 @@ fn test_remainder_long_settle_too_large_order_step_size() {
     assert_eq!(position.quote_asset_amount, -10);
     assert_eq!(position.remainder_base_asset_amount, 10);
     assert_eq!(market.amm.base_asset_amount_with_unsettled_lp, -10);
-    // net baa doesnt change
-    assert_eq!(
-        og_market.amm.base_asset_amount_with_amm,
-        market.amm.base_asset_amount_with_amm
-    );
+    // net baa doesnt change after settle_lp_position
+    assert_eq!(market.amm.base_asset_amount_with_amm, 10);
 
     // burn
     let lp_shares = position.lp_shares;
@@ -273,7 +270,8 @@ fn test_remainder_overflows_too_large_order_step_size() {
     market.amm.base_asset_amount_per_lp = 10;
     market.amm.quote_asset_amount_per_lp = -10;
     market.amm.base_asset_amount_with_unsettled_lp = -10;
-    market.amm.base_asset_amount_short = -10;
+    market.amm.base_asset_amount_with_amm = 10;
+    market.amm.base_asset_amount_short = 0;
 
     settle_lp_position(&mut position, &mut market).unwrap();
 
@@ -283,24 +281,22 @@ fn test_remainder_overflows_too_large_order_step_size() {
     assert_eq!(position.quote_asset_amount, -10);
     assert_eq!(position.remainder_base_asset_amount, 10);
     assert_eq!(market.amm.base_asset_amount_with_unsettled_lp, -10);
-    // net baa doesnt change
-    assert_eq!(
-        og_market.amm.base_asset_amount_with_amm,
-        market.amm.base_asset_amount_with_amm
-    );
+    // net baa doesnt change after settle_lp_position
+    assert_eq!(market.amm.base_asset_amount_with_amm, 10);
 
-    market.amm.base_asset_amount_per_lp = BASE_PRECISION_I128 + 1;
-    market.amm.quote_asset_amount_per_lp = -16900000000;
-    market.amm.base_asset_amount_with_unsettled_lp = -(BASE_PRECISION_I128 + 1);
-    market.amm.base_asset_amount_short = -(BASE_PRECISION_I128 + 1);
+    market.amm.base_asset_amount_per_lp += BASE_PRECISION_I128 + 1;
+    market.amm.quote_asset_amount_per_lp += -16900000000;
+    market.amm.base_asset_amount_with_unsettled_lp += -(BASE_PRECISION_I128 + 1);
+    // market.amm.base_asset_amount_short ;
+    market.amm.base_asset_amount_with_amm += BASE_PRECISION_I128 + 1;
 
     settle_lp_position(&mut position, &mut market).unwrap();
 
-    assert_eq!(position.last_base_asset_amount_per_lp, 1000000001);
-    assert_eq!(position.last_quote_asset_amount_per_lp, -16900000000);
-    assert_eq!(position.quote_asset_amount, -16900000000);
+    assert_eq!(position.last_base_asset_amount_per_lp, 1000000011);
+    assert_eq!(position.last_quote_asset_amount_per_lp, -16900000010);
+    assert_eq!(position.quote_asset_amount, -16900000010);
     assert_eq!(position.base_asset_amount, 0);
-    assert_eq!(position.remainder_base_asset_amount, 1000000001);
+    assert_eq!(position.remainder_base_asset_amount, 1000000011);
     assert_eq!(
         (position.remainder_base_asset_amount as u64) < market.amm.order_step_size,
         true
@@ -315,11 +311,11 @@ fn test_remainder_overflows_too_large_order_step_size() {
     // not allowed to settle when remainder is above i32 but below order size
     assert!(settle_lp_position(&mut position, &mut market).is_err());
 
-    assert_eq!(position.last_base_asset_amount_per_lp, 1000000001);
-    assert_eq!(position.last_quote_asset_amount_per_lp, -16900000000);
-    assert_eq!(position.quote_asset_amount, -16900000000);
+    // assert_eq!(position.last_base_asset_amount_per_lp, 1000000001);
+    // assert_eq!(position.last_quote_asset_amount_per_lp, -16900000000);
+    assert_eq!(position.quote_asset_amount, -16900000010);
     assert_eq!(position.base_asset_amount, 0);
-    assert_eq!(position.remainder_base_asset_amount, 1000000001);
+    // assert_eq!(position.remainder_base_asset_amount, 1000000001);
     assert_eq!(
         (position.remainder_base_asset_amount as u64) < market.amm.order_step_size,
         true
@@ -329,13 +325,14 @@ fn test_remainder_overflows_too_large_order_step_size() {
     market.amm.base_asset_amount_per_lp = 5 * BASE_PRECISION_I128 + 1;
     market.amm.quote_asset_amount_per_lp = -116900000000;
     market.amm.base_asset_amount_with_unsettled_lp = -(5 * BASE_PRECISION_I128 + 1);
-    market.amm.base_asset_amount_short = -(5 * BASE_PRECISION_I128 + 1);
+    market.amm.base_asset_amount_short = -(5 * BASE_PRECISION_I128);
+    market.amm.base_asset_amount_with_amm = 1;
 
     settle_lp_position(&mut position, &mut market).unwrap();
-    assert_eq!(market.amm.base_asset_amount_with_amm, 0);
     assert_eq!(market.amm.base_asset_amount_with_unsettled_lp, -1);
-    assert_eq!(market.amm.base_asset_amount_short, -5000000001);
+    assert_eq!(market.amm.base_asset_amount_short, -5000000000);
     assert_eq!(market.amm.base_asset_amount_long, 5000000000);
+    assert_eq!(market.amm.base_asset_amount_with_amm, 1);
 
     assert_eq!(position.last_base_asset_amount_per_lp, 5000000001);
     assert_eq!(position.last_quote_asset_amount_per_lp, -116900000000);
@@ -357,9 +354,9 @@ fn test_remainder_overflows_too_large_order_step_size() {
     assert_eq!(position.base_asset_amount, 5000000000);
     assert_eq!(position.remainder_base_asset_amount, 0);
 
-    assert_eq!(market.amm.base_asset_amount_with_amm, -1);
+    assert_eq!(market.amm.base_asset_amount_with_amm, 0);
     assert_eq!(market.amm.base_asset_amount_with_unsettled_lp, 0);
-    assert_eq!(market.amm.base_asset_amount_short, -5000000001);
+    assert_eq!(market.amm.base_asset_amount_short, -5000000000);
     assert_eq!(market.amm.base_asset_amount_long, 5000000000);
 }
 
@@ -384,7 +381,7 @@ fn test_remainder_burn_large_order_step_size() {
     market.amm.base_asset_amount_per_lp = 10;
     market.amm.quote_asset_amount_per_lp = -10;
     market.amm.base_asset_amount_with_unsettled_lp = -10;
-    market.amm.base_asset_amount_short = -10;
+    market.amm.base_asset_amount_with_amm += 10;
 
     settle_lp_position(&mut position, &mut market).unwrap();
 
@@ -394,16 +391,13 @@ fn test_remainder_burn_large_order_step_size() {
     assert_eq!(position.quote_asset_amount, -10);
     assert_eq!(position.remainder_base_asset_amount, 10);
     assert_eq!(market.amm.base_asset_amount_with_unsettled_lp, -10);
-    // net baa doesnt change
-    assert_eq!(
-        og_market.amm.base_asset_amount_with_amm,
-        market.amm.base_asset_amount_with_amm
-    );
+    // net baa doesnt change after settle_lp_position
+    assert_eq!(market.amm.base_asset_amount_with_amm, 10);
 
     market.amm.base_asset_amount_per_lp = BASE_PRECISION_I128 + 1;
     market.amm.quote_asset_amount_per_lp = -16900000000;
-    market.amm.base_asset_amount_with_unsettled_lp = -(BASE_PRECISION_I128 + 1);
-    market.amm.base_asset_amount_short = -(BASE_PRECISION_I128 + 1);
+    market.amm.base_asset_amount_with_unsettled_lp += -(BASE_PRECISION_I128 + 1);
+    market.amm.base_asset_amount_with_amm += BASE_PRECISION_I128 + 1;
 
     settle_lp_position(&mut position, &mut market).unwrap();
 
@@ -500,7 +494,7 @@ pub fn test_lp_settle_pnl() {
     market.amm.base_asset_amount_per_lp = 10;
     market.amm.quote_asset_amount_per_lp = -10;
     market.amm.base_asset_amount_with_unsettled_lp = -10;
-    market.amm.base_asset_amount_short = -10;
+    market.amm.base_asset_amount_with_amm += 10;
     market.amm.cumulative_funding_rate_long = 169;
     market.amm.cumulative_funding_rate_short = 169;
 
@@ -862,7 +856,7 @@ fn test_lp_has_correct_entry_be_price_sim_no_remainders() {
     assert_eq!(market.amm.sqrt_k, 2000000000);
     assert_eq!(position.get_entry_price().unwrap(), 0);
     assert_eq!(position.get_cost_basis().unwrap(), 0);
-    assert_eq!(position.get_be_price().unwrap(), 0);
+    assert_eq!(position.get_breakeven_price().unwrap(), 0);
     assert_eq!(position.remainder_base_asset_amount, 0);
     assert_eq!(position.base_asset_amount, 0);
     let mut num_position_flips = 0;
@@ -900,7 +894,7 @@ fn test_lp_has_correct_entry_be_price_sim_no_remainders() {
         }
 
         let entry = position.get_entry_price().unwrap();
-        let be = position.get_be_price().unwrap();
+        let be = position.get_breakeven_price().unwrap();
         let cb = position.get_cost_basis().unwrap();
 
         let iii = position
@@ -918,13 +912,13 @@ fn test_lp_has_correct_entry_be_price_sim_no_remainders() {
         );
         assert_eq!(position.remainder_base_asset_amount, 0);
 
-        if position.get_current_base_with_remainder_abs().unwrap() != 0 {
+        if position.get_base_asset_amount_with_remainder_abs().unwrap() != 0 {
             assert!(entry <= 100 * PRICE_PRECISION as i128);
             assert!(entry >= 99 * PRICE_PRECISION as i128);
         }
     }
     let entry = position.get_entry_price().unwrap();
-    let be = position.get_be_price().unwrap();
+    let be = position.get_breakeven_price().unwrap();
     let cb = position.get_cost_basis().unwrap();
 
     assert_eq!(position.base_asset_amount, 200500000000);
@@ -959,7 +953,7 @@ fn test_lp_has_correct_entry_be_price_sim() {
     assert_eq!(market.amm.sqrt_k, 2000000000);
     assert_eq!(position.get_entry_price().unwrap(), 0);
     assert_eq!(position.get_cost_basis().unwrap(), 0);
-    assert_eq!(position.get_be_price().unwrap(), 0);
+    assert_eq!(position.get_breakeven_price().unwrap(), 0);
     assert_eq!(position.remainder_base_asset_amount, 0);
     assert_eq!(position.base_asset_amount, 0);
     let mut num_position_flips = 0;
@@ -1040,7 +1034,7 @@ fn test_lp_has_correct_entry_be_price_sim() {
         }
 
         let entry = position.get_entry_price().unwrap();
-        let be = position.get_be_price().unwrap();
+        let be = position.get_breakeven_price().unwrap();
         let cb = position.get_cost_basis().unwrap();
 
         let iii = position
@@ -1058,13 +1052,13 @@ fn test_lp_has_correct_entry_be_price_sim() {
         );
         // assert_ne!(position.remainder_base_asset_amount, 0);
 
-        if position.get_current_base_with_remainder_abs().unwrap() != 0 {
+        if position.get_base_asset_amount_with_remainder_abs().unwrap() != 0 {
             assert!(entry <= 100 * PRICE_PRECISION as i128);
             assert!(entry >= 99 * PRICE_PRECISION as i128);
         }
     }
     let entry = position.get_entry_price().unwrap();
-    let be = position.get_be_price().unwrap();
+    let be = position.get_breakeven_price().unwrap();
     let cb = position.get_cost_basis().unwrap();
 
     assert_eq!(entry, 99202570);
@@ -1099,7 +1093,7 @@ fn test_lp_has_correct_entry_be_price_sim_more_flips() {
     assert_eq!(market.amm.sqrt_k, 2000000000);
     assert_eq!(position.get_entry_price().unwrap(), 0);
     assert_eq!(position.get_cost_basis().unwrap(), 0);
-    assert_eq!(position.get_be_price().unwrap(), 0);
+    assert_eq!(position.get_breakeven_price().unwrap(), 0);
     assert_eq!(position.remainder_base_asset_amount, 0);
     assert_eq!(position.base_asset_amount, 0);
     let mut num_position_flips = 0;
@@ -1138,7 +1132,7 @@ fn test_lp_has_correct_entry_be_price_sim_more_flips() {
         assert_eq!(position.remainder_base_asset_amount, 0);
 
         let entry = position.get_entry_price().unwrap();
-        let be = position.get_be_price().unwrap();
+        let be = position.get_breakeven_price().unwrap();
         let cb = position.get_cost_basis().unwrap();
 
         let iii = position
@@ -1155,7 +1149,7 @@ fn test_lp_has_correct_entry_be_price_sim_more_flips() {
             position.base_asset_amount,
         );
 
-        if position.get_current_base_with_remainder_abs().unwrap() != 0 {
+        if position.get_base_asset_amount_with_remainder_abs().unwrap() != 0 {
             assert!(entry <= 99_800_000 as i128);
             assert!(entry >= 99_199_820 as i128);
         }
@@ -1165,7 +1159,7 @@ fn test_lp_has_correct_entry_be_price_sim_more_flips() {
     // assert_eq!(flip_indexes, [0, 1, 18, 19]);
 
     let entry = position.get_entry_price().unwrap();
-    let be = position.get_be_price().unwrap();
+    let be = position.get_breakeven_price().unwrap();
     let cb = position.get_cost_basis().unwrap();
 
     assert_eq!(position.base_asset_amount, 150200000000);
diff --git a/programs/drift/src/controller/position.rs b/programs/drift/src/controller/position.rs
@@ -134,16 +134,17 @@ pub fn update_position_and_market(
             (new_quote_entry_amount, new_quote_break_even_amount, 0_i64)
         }
         PositionUpdateType::Reduce | PositionUpdateType::Close => {
-            let current_base_i128 = position.get_current_base_with_remainder_abs()?;
+            let current_base_i128 = position.get_base_asset_amount_with_remainder_abs()?;
             let delta_base_i128 = delta.get_delta_base_with_remainder_abs()?;
-            let ddd = position
-                .quote_entry_amount
-                .cast::<i128>()?
-                .safe_mul(delta_base_i128)?
-                .safe_div(current_base_i128)?
-                .cast()?;
 
-            let new_quote_entry_amount = position.quote_entry_amount.safe_sub(ddd)?;
+            let new_quote_entry_amount = position.quote_entry_amount.safe_sub(
+                position
+                    .quote_entry_amount
+                    .cast::<i128>()?
+                    .safe_mul(delta_base_i128)?
+                    .safe_div(current_base_i128)?
+                    .cast()?,
+            )?;
 
             let new_quote_break_even_amount = position.quote_break_even_amount.safe_sub(
                 position
@@ -162,7 +163,7 @@ pub fn update_position_and_market(
             (new_quote_entry_amount, new_quote_break_even_amount, pnl)
         }
         PositionUpdateType::Flip => {
-            let current_base_i128 = position.get_current_base_with_remainder_abs()?;
+            let current_base_i128 = position.get_base_asset_amount_with_remainder_abs()?;
             let delta_base_i128 = delta.get_delta_base_with_remainder_abs()?;
 
             // same calculation for new_quote_entry_amount
diff --git a/programs/drift/src/controller/position/tests.rs b/programs/drift/src/controller/position/tests.rs
@@ -526,7 +526,7 @@ fn test_position_entry_sim() {
     assert_eq!(pnl, -20000);
     assert_eq!(existing_position.base_asset_amount, 300000000);
     assert_eq!(existing_position.get_entry_price().unwrap(), 99345000);
-    assert_eq!(existing_position.get_be_price().unwrap(), 99345000);
+    assert_eq!(existing_position.get_breakeven_price().unwrap(), 99345000);
 
     let position_delta_to_flip = PositionDelta {
         base_asset_amount: -BASE_PRECISION_I64,
@@ -541,7 +541,7 @@ fn test_position_entry_sim() {
     assert_eq!(pnl, 0);
     assert_eq!(existing_position.base_asset_amount, -700000000);
     assert_eq!(existing_position.get_entry_price().unwrap(), 99345000);
-    assert_eq!(existing_position.get_be_price().unwrap(), 99345000);
+    assert_eq!(existing_position.get_breakeven_price().unwrap(), 99345000);
 }
 
 #[test]
diff --git a/programs/drift/src/math/position.rs b/programs/drift/src/math/position.rs
@@ -149,7 +149,6 @@ pub fn get_position_update_type(
     delta: &PositionDelta,
 ) -> DriftResult<PositionUpdateType> {
     if position.base_asset_amount == 0 && position.remainder_base_asset_amount == 0 {
-        crate::msg!("open");
         return Ok(PositionUpdateType::Open);
     }
 
diff --git a/programs/drift/src/state/user.rs b/programs/drift/src/state/user.rs
@@ -903,8 +903,8 @@ impl PerpPosition {
         }
     }
 
-    pub fn get_be_price(&self) -> DriftResult<i128> {
-        let base_with_remainder = self.get_base_asset_amount_w_remainder()?;
+    pub fn get_breakeven_price(&self) -> DriftResult<i128> {
+        let base_with_remainder = self.get_base_asset_amount_with_remainder()?;
         if base_with_remainder == 0 {
             return Ok(0);
         }
@@ -916,7 +916,7 @@ impl PerpPosition {
     }
 
     pub fn get_entry_price(&self) -> DriftResult<i128> {
-        let base_with_remainder = self.get_base_asset_amount_w_remainder()?;
+        let base_with_remainder = self.get_base_asset_amount_with_remainder()?;
         if base_with_remainder == 0 {
             return Ok(0);
         }
@@ -945,7 +945,7 @@ impl PerpPosition {
         Ok(unrealized_pnl)
     }
 
-    pub fn get_base_asset_amount_w_remainder(&self) -> DriftResult<i128> {
+    pub fn get_base_asset_amount_with_remainder(&self) -> DriftResult<i128> {
         if self.remainder_base_asset_amount != 0 {
             self.base_asset_amount
                 .cast::<i128>()?
@@ -955,8 +955,8 @@ impl PerpPosition {
         }
     }
 
-    pub fn get_current_base_with_remainder_abs(&self) -> DriftResult<i128> {
-        Ok(self.get_base_asset_amount_w_remainder()?.abs())
+    pub fn get_base_asset_amount_with_remainder_abs(&self) -> DriftResult<i128> {
+        Ok(self.get_base_asset_amount_with_remainder()?.abs())
     }
 
     pub fn get_claimable_pnl(&self, oracle_price: i64, pnl_pool_excess: i128) -> DriftResult<i128> {
diff --git a/programs/drift/src/validation/perp_market.rs b/programs/drift/src/validation/perp_market.rs

Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,6 @@ pub fn get_position_update_type(`
`149`	`149`	`delta: &PositionDelta,`
`150`	`150`	`) -> DriftResult<PositionUpdateType> {`
`151`	`151`	`if position.base_asset_amount == 0 && position.remainder_base_asset_amount == 0 {`
`152`		`- crate::msg!("open");`
`153`	`152`	`return Ok(PositionUpdateType::Open);`
`154`	`153`	`}`
`155`	`154`
Original file line number	Diff line number	Diff line change
`@@ -903,8 +903,8 @@ impl PerpPosition {`
`903`	`903`	`}`
`904`	`904`	`}`
`905`	`905`
`906`		`- pub fn get_be_price(&self) -> DriftResult<i128> {`
`907`		`- let base_with_remainder = self.get_base_asset_amount_w_remainder()?;`
	`906`	`+ pub fn get_breakeven_price(&self) -> DriftResult<i128> {`
	`907`	`+ let base_with_remainder = self.get_base_asset_amount_with_remainder()?;`
`908`	`908`	`if base_with_remainder == 0 {`
`909`	`909`	`return Ok(0);`
`910`	`910`	`}`
`@@ -916,7 +916,7 @@ impl PerpPosition {`
`916`	`916`	`}`
`917`	`917`
`918`	`918`	`pub fn get_entry_price(&self) -> DriftResult<i128> {`
`919`		`- let base_with_remainder = self.get_base_asset_amount_w_remainder()?;`
	`919`	`+ let base_with_remainder = self.get_base_asset_amount_with_remainder()?;`
`920`	`920`	`if base_with_remainder == 0 {`
`921`	`921`	`return Ok(0);`
`922`	`922`	`}`
`@@ -945,7 +945,7 @@ impl PerpPosition {`
`945`	`945`	`Ok(unrealized_pnl)`
`946`	`946`	`}`
`947`	`947`
`948`		`- pub fn get_base_asset_amount_w_remainder(&self) -> DriftResult<i128> {`
	`948`	`+ pub fn get_base_asset_amount_with_remainder(&self) -> DriftResult<i128> {`
`949`	`949`	`if self.remainder_base_asset_amount != 0 {`
`950`	`950`	`self.base_asset_amount`
`951`	`951`	`.cast::<i128>()?`
`@@ -955,8 +955,8 @@ impl PerpPosition {`
`955`	`955`	`}`
`956`	`956`	`}`
`957`	`957`
`958`		`- pub fn get_current_base_with_remainder_abs(&self) -> DriftResult<i128> {`
`959`		`- Ok(self.get_base_asset_amount_w_remainder()?.abs())`
	`958`	`+ pub fn get_base_asset_amount_with_remainder_abs(&self) -> DriftResult<i128> {`
	`959`	`+ Ok(self.get_base_asset_amount_with_remainder()?.abs())`
`960`	`960`	`}`
`961`	`961`
`962`	`962`	`pub fn get_claimable_pnl(&self, oracle_price: i64, pnl_pool_excess: i128) -> DriftResult<i128> {`