lb_libraries test coverage ----> 94%

Author: itsHaseebSaeed

contracts/liquidity_book/tests/Cargo.toml

@@ -18,7 +18,7 @@ default = []
 backtraces = ["cosmwasm-std/backtraces"]
 
 [dependencies]
-shade-protocol = { version = "0.1.0", path = "../../../packages/shade_protocol", features = ["liquidity_book_impl"] }
+shade-protocol = { version = "0.1.0", path = "../../../packages/shade_protocol", features = ["liquidity_book_impl","liquidity_book"] }
 schemars = "0.8.16"
 serde = { version = "1.0" }
 serde-json-wasm = { version = "1.0"}

packages/shade_protocol/Cargo.toml

@@ -23,8 +23,11 @@ required-features = [
 [lib]
 crate-type = ["cdylib", "rlib"]
 
+
+
 [features]
-default = ["utils"]
+default = ["utils", "liquidity_book"]
+
 
 # Utils
 utils = ["chrono"]

packages/shade_protocol/src/contract_interfaces/liquidity_book/Screenshot 2023-12-20 at 10.22.03 AM.png

@@ -565,15 +565,11 @@ impl BinHelper {
 mod tests {
     use super::*;
 
+    use super::super::{math::encoded_sample::EncodedSample, types::StaticFeeParameters};
     use crate::c_std::StdResult;
     use ethnum::U256;
-    use super::super::{
-        math::encoded_sample::EncodedSample,
-        types::StaticFeeParameters,
-    };
     use std::str::FromStr;
 
-
     fn assert_approxeq_abs(a: U256, b: U256, max_diff: U256, msg: &str) {
         let diff = if a > b { a - b } else { b - a };
         assert!(diff <= max_diff, "{}: diff was {:?}", msg, diff);
@@ -692,6 +688,47 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_get_shares_and_effective_amounts_in_delta_liquidity_adjustment() {
+        // Assume these constants based on your SCALE and SCALE_OFFSET values
+        let scale = U256::from(SCALE);
+        let scale_offset = U256::from(SCALE_OFFSET);
+
+        // Sample input values to trigger the condition
+        let bin_reserves = Bytes32::encode(1000, 2000); // bin reserves
+        let price = U256::from(10u128); // price
+        let total_supply = U256::from(10000u128); // total supply
+        let user_liquidity = U256::from(1000u128); // user liquidity
+        let bin_liquidity = U256::from(5000u128); // bin liquidity
+        let shares =
+            U256x256Math::mul_div_round_down(user_liquidity, total_supply, bin_liquidity).unwrap();
+        let effective_liquidity =
+            U256x256Math::mul_div_round_up(shares, bin_liquidity, total_supply).unwrap();
+
+        // Adjusting amounts_in to ensure delta_liquidity calculation triggers the specific condition
+        let mut amounts_in = Bytes32::encode(500, 1000);
+        if user_liquidity > effective_liquidity {
+            let delta_liquidity = user_liquidity - effective_liquidity;
+            amounts_in = Bytes32::encode(
+                500,
+                1000 + ((delta_liquidity >> scale_offset.as_u32()).as_u128()),
+            );
+        }
+
+        // Execute the method
+        let result = BinHelper::get_shares_and_effective_amounts_in(
+            bin_reserves,
+            amounts_in,
+            price,
+            total_supply,
+        )
+        .unwrap();
+
+        // Assertions
+        assert!(result.1.decode_y() == 1000);
+        assert!(result.1.decode_x() == 500);
+    }
+
     #[test]
     fn test_get_shares_and_effective_amounts_in() -> StdResult<()> {
         let mut total_supply = U256::from_str("0").unwrap();
@@ -962,4 +999,57 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_verify_amounts_with_flawed_factor_id_less_than_active_id() {
+        let amounts = Bytes32::encode(1, 0); // Right-side 128 bits greater than zero
+        let active_id = 2;
+        let id = 1;
+        let result = BinHelper::verify_amounts(amounts, active_id, id);
+
+        match result {
+            Err(BinError::CompositionFactorFlawed(error_id)) => assert_eq!(error_id, id),
+            _ => panic!("Expected CompositionFactorFlawed error"),
+        }
+    }
+
+    #[test]
+    fn test_verify_amounts_with_flawed_factor_id_greater_than_active_id() {
+        let amounts = U256::from(u128::MAX) + U256::ONE; // Greater than u128::MAX
+        let active_id = 1;
+        let id = 2;
+        let result = BinHelper::verify_amounts(amounts.to_le_bytes(), active_id, id);
+
+        match result {
+            Err(BinError::CompositionFactorFlawed(error_id)) => assert_eq!(error_id, id),
+            _ => panic!("Expected CompositionFactorFlawed error"),
+        }
+    }
+
+    #[test]
+    fn test_verify_amounts_valid_case_id_less_than_active_id() {
+        let amounts = Bytes32::encode(0, 0); // Right-side 128 bits are zero
+        let active_id = 2;
+        let id = 1;
+        let result = BinHelper::verify_amounts(amounts, active_id, id);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_verify_amounts_valid_case_id_greater_than_active_id() {
+        let amounts = U256::from(u128::MAX).to_le_bytes(); // Not greater than u128::MAX
+        let active_id = 1;
+        let id = 2;
+        let result = BinHelper::verify_amounts(amounts, active_id, id);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_verify_amounts_valid_case_id_equals_active_id() {
+        let amounts = Bytes32::encode(0, 0); // Any value is fine, as id == active_id
+        let active_id = 1;
+        let id = 1;
+        let result = BinHelper::verify_amounts(amounts, active_id, id);
+        assert!(result.is_ok());
+    }
 }

packages/shade_protocol/src/contract_interfaces/liquidity_book/lb_libraries/bin_helper.rs

@@ -3,7 +3,7 @@
 //!
 //! Helper library used for setting and decoding parts of encoded Bytes32.
 
-use crate::lb_libraries::types::Bytes32;
+use crate::liquidity_book::lb_libraries::types::Bytes32;
 use cosmwasm_schema::cw_serde;
 use ethnum::U256;
 

packages/shade_protocol/src/contract_interfaces/liquidity_book/lb_libraries/math/encoded_sample.rs

@@ -6,13 +6,13 @@
 use cosmwasm_schema::cw_serde;
 use ethnum::U256;
 
-use crate::lb_libraries::types::Bytes32;
+use crate::liquidity_book::lb_libraries::types::Bytes32;
 
 use super::packed_u128_math::PackedUint128Math;
 
 pub const PRECISION: u64 = 1_000_000_000_000_000_000; // 1e18
 
-#[derive(thiserror::Error, Debug)]
+#[derive(thiserror::Error, Debug, PartialEq)]
 pub enum LiquidityConfigurationsError {
     #[error("Liquidity Configurations Error: Distribution must be less than PRECISION")]
     InvalidConfig,
@@ -132,4 +132,71 @@ mod tests {
 
         assert_eq!(result, (expected_amounts, 0));
     }
+
+    #[test]
+    fn test_new_valid_config() {
+        let lc = LiquidityConfigurations::new(500_000_000_000_000_000, 500_000_000_000_000_000, 1);
+        assert!(lc.is_ok());
+    }
+
+    #[test]
+    fn test_new_invalid_config_x() {
+        let lc = LiquidityConfigurations::new(PRECISION + 1, 500_000_000_000_000_000, 1);
+        assert_eq!(lc, Err(LiquidityConfigurationsError::InvalidConfig));
+    }
+
+    #[test]
+    fn test_new_invalid_config_y() {
+        let lc = LiquidityConfigurations::new(500_000_000_000_000_000, PRECISION + 1, 1);
+        assert_eq!(lc, Err(LiquidityConfigurationsError::InvalidConfig));
+    }
+
+    #[test]
+    fn test_update_distribution_valid() {
+        let mut lc =
+            LiquidityConfigurations::new(300_000_000_000_000_000, 300_000_000_000_000_000, 1)
+                .unwrap();
+        let result = lc.update_distribution(400_000_000_000_000_000, 400_000_000_000_000_000);
+        assert!(result.is_ok());
+        assert_eq!(lc.distribution_x, 400_000_000_000_000_000);
+        assert_eq!(lc.distribution_y, 400_000_000_000_000_000);
+    }
+
+    #[test]
+    fn test_update_distribution_invalid_x() {
+        let mut lc =
+            LiquidityConfigurations::new(300_000_000_000_000_000, 300_000_000_000_000_000, 1)
+                .unwrap();
+        let result = lc.update_distribution(PRECISION + 1, 400_000_000_000_000_000);
+        assert_eq!(result, Err(LiquidityConfigurationsError::InvalidConfig));
+    }
+
+    #[test]
+    fn test_update_distribution_invalid_y() {
+        let mut lc =
+            LiquidityConfigurations::new(300_000_000_000_000_000, 300_000_000_000_000_000, 1)
+                .unwrap();
+        let result = lc.update_distribution(400_000_000_000_000_000, PRECISION + 1);
+        assert_eq!(result, Err(LiquidityConfigurationsError::InvalidConfig));
+    }
+    #[test]
+    fn test_equality() {
+        let config1 = LiquidityConfigurations::new(100, 200, 1).unwrap();
+        let config2 = LiquidityConfigurations::new(100, 200, 1).unwrap();
+        assert_eq!(config1, config2);
+    }
+
+    #[test]
+    fn test_debug_format() {
+        let config = LiquidityConfigurations::new(100, 200, 1).unwrap();
+        let debug_string = format!("{:?}", config);
+        assert!(!debug_string.is_empty());
+    }
+
+    #[test]
+    fn test_clone() {
+        let config = LiquidityConfigurations::new(100, 200, 1).unwrap();
+        let cloned_config = config.clone();
+        assert_eq!(config, cloned_config);
+    }
 }

packages/shade_protocol/src/contract_interfaces/liquidity_book/lb_libraries/math/liquidity_configurations.rs

@@ -7,7 +7,7 @@
 //! u128 is a 128-bit unsigned integer type, which means that its little-endian byte representation is 16 bytes long.
 //! A `Bytes32` value is a `[u8; 32]` and can hold 256 bits, or two `u128` values.
 
-use crate::{c_std::StdError, lb_libraries::types::Bytes32};
+use crate::{c_std::StdError, liquidity_book::lb_libraries::types::Bytes32};
 
 pub const BASIS_POINT_MAX: u128 = 10_000;
 

packages/shade_protocol/src/contract_interfaces/liquidity_book/lb_libraries/math/packed_u128_math.rs

@@ -8,7 +8,7 @@ use ethnum::U256;
 use std::collections::HashMap;
 
 use super::{bit_math::BitMath, u24::U24};
-use crate::lb_libraries::types::Bytes32;
+use crate::liquidity_book::lb_libraries::types::Bytes32;
 
 // TODO - This module is likely inefficient because we don't have bit ops for Bytes32.
 //      - Other libraries could benefit from Bytes32 bit ops also...

packages/shade_protocol/src/contract_interfaces/liquidity_book/lb_libraries/math/tree_math.rs

@@ -6,7 +6,7 @@
 
 use ethnum::{I256, U256};
 
-use crate::lb_libraries::constants::*;
+use crate::liquidity_book::lb_libraries::constants::*;
 
 use super::bit_math::BitMath;
 
@@ -165,6 +165,7 @@ impl U128x128Math {
 
 #[cfg(test)]
 mod tests {
+    use core::panic;
     use std::str::FromStr;
 
     use super::*;
@@ -188,12 +189,9 @@ mod tests {
 
     #[test]
     fn test_pow_and_log() {
-        println!("{}", LOG_SCALE);
-        println!("{}", LOG_SCALE_SQUARED);
         let x = (U256::from((1.0001 * PRECISION as f64) as u128) << 128) / PRECISION;
         let y = 100_000;
         let res = U128x128Math::pow(x, y.into()).unwrap();
-        // let expected = U256::from(7491471493045233295460405875225305845649644);
         let tolerance = 10 ^ 12;
 
         let expected = U256::from_str("7491471493045233295460405875225305845649644").unwrap();
@@ -220,4 +218,56 @@ mod tests {
             "test_pow_and_log::1 failed"
         );
     }
+    #[test]
+    fn test_log2_x_equals_1() {
+        let x = U256::ONE;
+        let result = U128x128Math::log2(x).unwrap();
+        assert_eq!(result, I256::from(-128));
+    }
+
+    #[test]
+    fn test_log2_x_equals_0() {
+        let x = U256::ZERO;
+        let result = U128x128Math::log2(x);
+
+        assert!(matches!(result, Err(U128x128MathError::LogUnderflow)));
+    }
+
+    #[test]
+    fn test_pow_y_equals_0() {
+        let x = U256::from(123456789u128);
+        let y = I256::ZERO;
+        let result = U128x128Math::pow(x, y).unwrap();
+        assert_eq!(result, SCALE);
+    }
+
+    #[test]
+    fn test_pow_y_negative() {
+        let x = U256::from(123456789u128);
+        let y = I256::from(-1);
+        let _result = U128x128Math::pow(x, y).unwrap();
+        assert_eq!(
+            _result.to_string(),
+            "937915931357296158282320018939484225960793332034907890237268231623237"
+        );
+    }
+
+    #[test]
+    fn test_pow_y_positive() {
+        let x = U256::from(123456789u128);
+        let y = I256::from(1);
+        let _result = U128x128Math::pow(x, y).unwrap();
+        assert_eq!(_result.to_string(), "123456789");
+    }
+
+    #[test]
+    fn test_pow_invert_result() {
+        let x = U256::from(0xffffffffffffffffffffffffffffffffu128);
+        let y = I256::from(-1);
+        let _result = U128x128Math::pow(x, y).unwrap();
+        assert_eq!(
+            _result.to_string(),
+            "340282366920938463463374607431768211457"
+        );
+    }
 }