## Summary Stable pools are heavily favored in rewards distribution. ## Finding Description The process to configure rewards to be distributed is as follows : * An `admin` calls [config_pool_rewards](https://cantina.xyz/code/990ce947-05da-443e-b397-be38a65f0bff/liquidity_pool_router/src/contract.rs?lines=736,775) with the target rewards TPS, their expiration and a list of tuples where each one defines a list of tokens and it's corresponding voting shares. This sets the necessary structures for the remaining steps of the process. * Anyone can then call [fill_liquidity](https://cantina.xyz/code/990ce947-05da-443e-b397-be38a65f0bff/liquidity_pool_router/src/contract.rs?lines=782,806) with a list of tokens (one that was configured in the previous step). This uses the configured `liquidity_calculator` contract to get the liquidities of all pools (standard and stable) that use those tokens and store them for the next step. * Anyone can now call [config_pool_rewards](https://cantina.xyz/code/990ce947-05da-443e-b397-be38a65f0bff/liquidity_pool_router/src/contract.rs?lines=829,899), specifying a list of tokens and one of the pools corresponding to it to set its rewards. This set the rewards TPS of the pool based on : * The voting shares of the tokens it uses. * The ratio of its calculated liquidity and the total calculated liquidity of all pools using the same tokens. This issue arises due to how pool liquidities are calculated : * For [standard](https://cantina.xyz/code/990ce947-05da-443e-b397-be38a65f0bff/liquidity_pool_liquidity_calculator/src/standard_pool.rs?lines=73,82) pools. ```rust pub fn get_liquidity( e: &Env, fee_fraction: u128, reserves: &Vec, in_idx: u32, _out_idx: u32, ) -> u128 { let x = reserves.get(in_idx).unwrap(); x.fixed_mul_floor(e, &FEE_MULTIPLIER, &(56 * (FEE_MULTIPLIER - fee_fraction))) } ``` * For [stable](https://cantina.xyz/code/990ce947-05da-443e-b397-be38a65f0bff/liquidity_pool_liquidity_calculator/src/stableswap_pool.rs?lines=175,318) pools ```rust pub fn get_liquidity( e: &Env, fee_fraction: u128, amp: u128, xp_adj: &Vec, xp_norm: &Vec, d_adj: u128, d_norm: u128, in_idx: u32, out_idx: u32, ) -> u128 { let xp_in = xp_norm.get(in_idx).unwrap(); let xp_out = xp_norm.get(out_idx).unwrap(); if xp_in == 0 || xp_out == 0 { return 0; } let mut result_big = 0; let min_amount = PRECISION; let min_estimate = estimate_swap( e, fee_fraction, d_adj, amp, &xp_adj, in_idx, out_idx, min_amount, ); if min_estimate == 0 { return 0; } let min_price = min_amount * PRECISION / min_estimate; let mut prev_price = 0; let mut prev_weight = 1; let mut prev_depth = 0; let mut first_iteration = true; let mut last_iteration = false; // heuristic. 2x is because of weight function - after 1.6 it affects less than 1% let mut in_amt = get_max_reserve(&xp_norm) * 2; <@ while !last_iteration { let mut depth = estimate_swap( e, fee_fraction, d_norm, amp, &xp_norm, in_idx, out_idx, in_amt, ); if in_amt == 0 || depth == 0 { break; } let mut price = in_amt * PRECISION / depth; let mut weight = price_weight(price, min_price); if first_iteration { prev_price = price; prev_depth = depth; prev_weight = weight; first_iteration = false; continue; } if price > prev_price { if prev_price < min_price { break; } price = min_price; weight = 1; depth = 0; last_iteration = true; } let depth_avg = (depth + prev_depth) / 2; <@ let weight_avg = (weight + prev_weight) / 2; let d_price = prev_price - price; <@ let integration_result = depth_avg * PRECISION * weight_avg / PRECISION * d_price / PRECISION; result_big += integration_result; prev_price = price; prev_weight = weight; prev_depth = depth; in_amt = get_next_in_amt(in_amt); } result_big / PRECISION } pub(crate) fn get_pool_liquidity(e: &Env, fee_fraction: u128, amp: u128, xp: &Vec) -> U256 { let n_tokens = xp.len(); let (xp_norm, nominator, denominator) = normalize_reserves(xp); let mut result_big = U256::from_u128(e, 0); let mut xp_adj = Vec::new(e); for i in 0..n_tokens { xp_adj.push_back(xp_norm.get(i).unwrap() * PRECISION); } let d_adj = get_d(e, n_tokens, &xp_adj, amp); let d_norm = get_d(e, n_tokens, &xp_norm, amp); for in_idx in 0..n_tokens { for out_idx in 0..n_tokens { if in_idx == out_idx { continue; } result_big = result_big.add(&U256::from_u128( e, get_liquidity( <@ &e, fee_fraction, amp, &xp_adj, &xp_norm, d_adj, d_norm, in_idx, out_idx, ) * nominator / denominator, )); } } result_big } ``` At similar reserves, a stable pool calculated liquidity ends up being much higher than a standard pool calculated liquidity. This is due to the fact that the integration starts with a high starting in amount (double the maximum token reserve) in the stable pool calculation which make it seem like more liquidity is available as above the max reserve, the output amount does not change much (so depth average stays the same) but the price still changes considerably (so the price difference is high). It is normal in theory for stable pools to have more liquidity as they are more capital efficient. The main concern here is how much more liquidity is available which I believe is skewed in the current calculation because of unrealistic in amounts (therefore prices) being included. If I understand the proposal #82 correctly, the main intent is to fairly balance standard and stable pools rewards but as it stands right now, at similar reserves, a stable pool liquidity is consistently around ~9x more than a standard one, which means that the stable pool will get ~90% of the rewards. For instance, at similar reserves : * 1 stable pool, 1 standard pool => Rewards : 90%, 10% * 1 stable pool, 9 standard pools => Rewards : 50%, 50% * 3 stable pools, 7 standard pools => Rewards : 80%, 20% ## Impact Explanation For a given tokens pair, stable pool liquidity providers get significantly more rewards than standard pool liquidity providers. ## Likelihood Explanation Aquarius allows, for any given tokens pair, for up to 10 pools to be created of which a maximum of 3 can be stable pools. ## Proof of Concept ### Test Apply this diff and run `cargo test test_rewards_distribution_poc` : ```diff diff --git a/liquidity_pool_router/src/test.rs b/liquidity_pool_router/src/test.rs index e381114..6e17cbd 100644 --- a/liquidity_pool_router/src/test.rs +++ b/liquidity_pool_router/src/test.rs @@ -654,6 +654,95 @@ fn test_init_stable_pool_bad_tokens() { router.init_stableswap_pool(&user1, &tokens, &30); } +#[test] +fn test_rewards_distribution_poc() { + let setup = Setup::default(); + let e = setup.env; + let router = setup.router; + let admin = setup.admin; + let [token1, token2, _, _] = setup.tokens; + let reward_token = setup.reward_token; + + let tokens = Vec::from_array(&e, [token1.address.clone(), token2.address.clone()]); + + let user1 = Address::generate(&e); + router.configure_init_pool_payment(&admin, &reward_token.address, &0, &0, &router.address); + + let (standard_pool_hash, _) = router.init_standard_pool(&user1, &tokens, &30); + let (stable_pool_hash, _) = router.init_stableswap_pool(&user1, &tokens, &30); + + let reward_1_tps = 10_5000000_u128; + + token1.mint(&user1, &20_000_0000000); + + token2.mint(&user1, &20_000_0000000); + + let amount = 2_000_0000000; + + router.deposit( + &user1, + &tokens, + &standard_pool_hash, + &Vec::from_array(&e, [amount, 3 * amount]), + &0, + ); + + router.deposit( + &user1, + &tokens, + &stable_pool_hash, + &Vec::from_array(&e, [amount, 3 * amount]), + &0, + ); + + let rewards = Vec::from_array(&e, [(tokens.clone(), 1_0000000)]); + + router.config_global_rewards( + &admin, + &reward_1_tps, + &e.ledger().timestamp().saturating_add(60), + &rewards, + ); + + router.fill_liquidity(&tokens); + + let standard_pool_tps = router.config_pool_rewards(&tokens, &standard_pool_hash); + let stable_pool_tps = router.config_pool_rewards(&tokens, &stable_pool_hash); + + std::println!( + "Standard Pool Liquidity : {} - Stable Pool Liquidity : {}", + router + .get_liquidity(&tokens, &standard_pool_hash) + .to_u128() + .unwrap(), + router + .get_liquidity(&tokens, &stable_pool_hash) + .to_u128() + .unwrap() + ); + + std::println!( + "Standard Pool TPS : {} - Stable Pool TPS : {}", + standard_pool_tps, + stable_pool_tps + ); + + std::println!( + "Liquidity Ratio : {} - TPS Ratio : {}", + router + .get_liquidity(&tokens, &stable_pool_hash) + .to_u128() + .unwrap() + / router + .get_liquidity(&tokens, &standard_pool_hash) + .to_u128() + .unwrap(), + stable_pool_tps / standard_pool_tps + ); + + assert!(stable_pool_tps < 9 * standard_pool_tps); +} + #[test] fn test_simple_ongoing_reward() { let setup = Setup::default(); ``` ### Output ```console running 1 test Standard Pool Liquidity : 1432870038 - Stable Pool Liquidity : 13475488620 Standard Pool TPS : 10091745 - Stable Pool TPS : 94908254 Liquidity Ratio : 9 - TPS Ratio : 9 thread 'test::test_rewards_distribution_poc' panicked at liquidity_pool_router/src/test.rs:743:5: assertion failed: stable_pool_tps < 9 * standard_pool_tps note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace Writing test snapshot file for test "test::test_rewards_distribution_poc" to "test_snapshots/test/test_rewards_distribution_poc.1.json". test test::test_rewards_distribution_poc ... FAILED failures: failures: test::test_rewards_distribution_poc test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 72 filtered out; finished in 0.42s ``` ## Recommendation Set the starting in amount to the maximum reserve.

imsrybr0

Public reviews