fix: slippage calulation and added tests

contracts/hub/vlp/src/query.rs

@@ -221,11 +221,15 @@ pub fn assert_slippage_tolerance(
     pool_ratio: Decimal256,
     slippage_tolerance_bps: u64,
 ) -> Result<bool, ContractError> {
-    let slippage = pool_ratio.abs_diff(ratio);
+    let slippage = ratio.abs_diff(pool_ratio).checked_div(pool_ratio)?;
+
     let slippage_tolerance = Decimal256::bps(slippage_tolerance_bps);
     ensure!(
         slippage.le(&slippage_tolerance),
-        ContractError::LiquiditySlippageExceeded {}
+        ContractError::LiquiditySlippageExceeded {
+            expected: slippage,
+            received: slippage_tolerance,
+        }
     );
     Ok(true)
 }

contracts/hub/vlp/src/tests.rs

@@ -2,9 +2,10 @@
 #[cfg(test)]
 mod tests {
     use crate::contract::{execute, instantiate};
+    use crate::query::{calculate_lp_allocation, calculate_lp_allocation_for_liquidity};
     use crate::state::{State, BALANCES, CHAIN_LP_TOKENS, STATE};
     use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
-    use cosmwasm_std::{coins, DepsMut, Response, Uint128};
+    use cosmwasm_std::{coins, Decimal256, DepsMut, Response, Uint128};
     use euclid::chain::{ChainUid, CrossChainUser};
     use euclid::error::ContractError;
     use euclid::fee::{DenomFees, Fee, TotalFees};
@@ -181,4 +182,55 @@
             ContractError::new("Euclid Fee cannot exceed maximum limit")
         );
     }
+
+    #[test]
+    fn test_calculate_lp_allocation_for_liquidity() {
+        let token_1_liquidity = Uint128::new(980);
+        let token_2_liquidity = Uint128::new(1000);
+        let total_reserve_1 = Uint128::new(10000);
+        let total_reserve_2 = Uint128::new(10000);
+        let total_lp_tokens = Uint128::new(10000); // 1:1 ratio for lp tokens to tokens present
+        let slippage_tolerance_bps = Some(200); // 2% slippage tolerance
+
+        // Call the function to test
+        let lp_allocation = calculate_lp_allocation_for_liquidity(
+            token_1_liquidity,
+            token_2_liquidity,
+            total_reserve_1,
+            total_reserve_2,
+            total_lp_tokens,
+            slippage_tolerance_bps,
+        )
+        .unwrap();
+
+        // Assert the expected LP allocation
+        let expected_allocation = Uint128::new(980); // This value should be calculated based on the logic
+        assert_eq!(lp_allocation, expected_allocation);
+    }
+
+    #[test]
+    fn test_calculate_lp_allocation_for_liquidity_exceeded_slippage() {
+        let token_1_liquidity = Uint128::new(100);
+        let token_2_liquidity = Uint128::new(99);
+        let total_reserve_1 = Uint128::new(100);
+        let total_reserve_2 = Uint128::new(100);
+        let total_lp_tokens = Uint128::new(100);
+        let slippage_tolerance_bps = Some(0); // 0% slippage tolerance to force failure
+
+        // Call the function to test and expect an error
+        let err = calculate_lp_allocation_for_liquidity(
+            token_1_liquidity,
+            token_2_liquidity,
+            total_reserve_1,
+            total_reserve_2,
+            total_lp_tokens,
+            slippage_tolerance_bps,
+        )
+        .unwrap_err();
+
+        match err {
+            ContractError::LiquiditySlippageExceeded { .. } => (),
+            _ => panic!("Expected slippage exceeded error, got {:?}", err),
+        }
+    }
 }

packages/euclid/src/error.rs

@@ -1,8 +1,8 @@
 use std::num::ParseIntError;
 
 use cosmwasm_std::{
-    Addr, CheckedMultiplyFractionError, CheckedMultiplyRatioError, DivideByZeroError,
-    OverflowError, StdError, Uint128,
+    Addr, CheckedFromRatioError, CheckedMultiplyFractionError, CheckedMultiplyRatioError,
+    Decimal256, DivideByZeroError, OverflowError, StdError, Uint128,
 };
 use cw20_base::ContractError as Cw20ContractError;
 use thiserror::Error;
@@ -23,6 +23,9 @@ pub enum ContractError {
     #[error("{0}")]
     CheckedMultiplyRatioError(#[from] CheckedMultiplyRatioError),
 
+    #[error("{0}")]
+    CheckedFromRatioError(#[from] CheckedFromRatioError),
+
     #[error("{0}")]
     DivideByZero(#[from] DivideByZeroError),
 
@@ -94,7 +97,6 @@ pub enum ContractError {
 
     #[error("Not Implemented")]
     NotImplemented {},
-
     #[error("DenomDoesNotExist")]
     DenomDoesNotExist {},
 
@@ -194,8 +196,11 @@ pub enum ContractError {
     #[error("Liquity already exist in state for the sender")]
     LiquidityTxAlreadyExist {},
 
-    #[error("Slippage has been exceeded when providing liquidity.")]
-    LiquiditySlippageExceeded {},
+    #[error("Slippage has been exceeded when providing liquidity. Expected: {expected}, Received: {received}")]
+    LiquiditySlippageExceeded {
+        expected: Decimal256,
+        received: Decimal256,
+    },
 
     #[error("Pool Instantiate Failed {err}")]
     PoolInstantiateFailed { err: String },