Switch the liquidity shape to a triangle #2
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -31,7 +31,6 @@ macro_rules! define_error { | |
| define_error! { | ||
| RESOURCE_DOES_NOT_BELONG_ERROR | ||
| => "One or more of the resources do not belong to pool."; | ||
| NO_PRICE_ERROR => "Pool has no price."; | ||
| OVERFLOW_ERROR => "Overflow error."; | ||
| } | ||
|
|
@@ -249,88 +248,204 @@ pub mod adapter { | |
| let SelectedTicks { | ||
| higher_ticks, | ||
| lower_ticks, | ||
| lowest_tick, | ||
| highest_tick, | ||
| .. | ||
| } = SelectedTicks::select( | ||
| active_tick, | ||
| bin_span, | ||
| PREFERRED_TOTAL_NUMBER_OF_HIGHER_AND_LOWER_BINS, | ||
| ); | ||
|
|
||
| // Calculating the value of liquidity of the left side (all Y) and | ||
| // the value of liquidity of the right side (all X). Note that the | ||
| // equations used below are all derived from the following quadric | ||
| // equation: | ||
| // (sqrt(pa) / sqrt(pb) - 1) * L^2 + (x*sqrt(pa) + y / sqrt(pb)) * L + xy = 0 | ||
| // The equation for the left side can be derived by using the | ||
| // knowledge that it is entirely made up of Y and therefore X is | ||
| // zero. Similarly, we can derive the equation for the right side of | ||
| // liquidity by setting Y to zero. | ||
| // | ||
| // We can also find the equations used below in the paper | ||
| // https://atiselsts.github.io/pdfs/uniswap-v3-liquidity-math.pdf | ||
| // which are equations 5 and 9. | ||
| // | ||
| // Lets refer to the equation that finds the left side of liquidity | ||
| // as Ly and to the one that finds the right side of liquidity as | ||
| // Lx. We will use those named in some of the comments that follow. | ||
| let current_price = price; | ||
| let lowest_price = tick_to_spot(lowest_tick).expect(OVERFLOW_ERROR); | ||
| let highest_price = highest_tick | ||
| .checked_add(bin_span) | ||
| .and_then(tick_to_spot) | ||
| .expect(OVERFLOW_ERROR); | ||
|
|
||
| let current_price_sqrt = | ||
| current_price.checked_sqrt().expect(OVERFLOW_ERROR); | ||
| let lowest_price_sqrt = | ||
| lowest_price.checked_sqrt().expect(OVERFLOW_ERROR); | ||
| let highest_price_sqrt = | ||
| highest_price.checked_sqrt().expect(OVERFLOW_ERROR); | ||
|
|
||
| let liquidity = { | ||
| // This is equation 9 from the paper I shared above. Applied | ||
| // between the current price and the lowest price which is the | ||
| // range in which there is only Y. | ||
| let liquidity_y = current_price_sqrt | ||
| .checked_sub(lowest_price_sqrt) | ||
| .and_then(|sqrt_difference| { | ||
| amount_y.checked_div(sqrt_difference) | ||
| }) | ||
| .expect(OVERFLOW_ERROR); | ||
|
|
||
| // This is equation 5 from the paper I shared above. Applied | ||
| // between the current price and the highest price which is the | ||
| // range in which there is only X. | ||
| let liquidity_x = amount_x | ||
| .checked_mul(current_price_sqrt) | ||
| .and_then(|value| value.checked_mul(highest_price_sqrt)) | ||
| .and_then(|nominator| { | ||
| let denominator = highest_price_sqrt | ||
| .checked_sub(current_price_sqrt)?; | ||
|
|
||
| nominator.checked_div(denominator) | ||
| }) | ||
| .expect(OVERFLOW_ERROR); | ||
|
|
||
| // We define the liquidity as the minimum of the X and Y | ||
| // liquidity such that the position is always balanced. | ||
| min(liquidity_x, liquidity_y) | ||
| }; | ||
|
|
||
| // At this point, we have found the Lx and the Ly. This tells the | ||
| // liquidity value that should be in each of the bins. We now | ||
| // compute the exact amount that should go into each of the bins | ||
| // based on what's been calculated above. For this, we will derive | ||
| // an equation for x from Lx and an equation for y from Ly. | ||
|
|
||
| // The first one that we compute is how much should add to the | ||
| // currently active bin. | ||
| let (active_bin_amount_x, active_bin_amount_y) = { | ||
| let bin_lower_tick = active_tick; | ||
| let bin_higher_tick = | ||
| bin_lower_tick.checked_add(bin_span).expect(OVERFLOW_ERROR); | ||
|
|
||
| let bin_lower_price = | ||
| tick_to_spot(bin_lower_tick).expect(OVERFLOW_ERROR); | ||
| let bin_higher_price = | ||
| tick_to_spot(bin_higher_tick).expect(OVERFLOW_ERROR); | ||
|
|
||
| let bin_lower_price_sqrt = | ||
| bin_lower_price.checked_sqrt().expect(OVERFLOW_ERROR); | ||
| let bin_higher_price_sqrt = | ||
| bin_higher_price.checked_sqrt().expect(OVERFLOW_ERROR); | ||
|
|
||
| let amount_y = current_price_sqrt | ||
| .checked_sub(bin_lower_price_sqrt) | ||
| .and_then(|price_sqrt_difference| { | ||
| price_sqrt_difference.checked_mul(liquidity) | ||
| }) | ||
| .expect(OVERFLOW_ERROR); | ||
|
|
||
| let amount_x = bin_higher_price_sqrt | ||
| .checked_sub(current_price_sqrt) | ||
| .and_then(|price_sqrt_difference| { | ||
| price_sqrt_difference.checked_mul(liquidity) | ||
| }) | ||
| .and_then(|nominator| { | ||
| let denominator = current_price_sqrt | ||
| .checked_mul(bin_higher_price_sqrt)?; | ||
|
|
||
| nominator.checked_div(denominator) | ||
| }) | ||
| .expect(OVERFLOW_ERROR); | ||
|
|
||
| (amount_x, amount_y) | ||
| }; | ||
|
|
||
| let mut remaining_x = amount_x | ||
| .checked_sub(active_bin_amount_x) | ||
| .expect(OVERFLOW_ERROR); | ||
| let mut remaining_y = amount_y | ||
| .checked_sub(active_bin_amount_y) | ||
| .expect(OVERFLOW_ERROR); | ||
| let mut positions = | ||
| vec![(active_tick, active_bin_amount_x, active_bin_amount_y)]; | ||
|
|
||
| // Finding the amount of Y to contribute to each one of the lower | ||
| // bins (contain only Y). | ||
| for bin_lower_tick in lower_ticks.iter().copied() { | ||
| let bin_higher_tick = | ||
| bin_lower_tick.checked_add(bin_span).expect(OVERFLOW_ERROR); | ||
|
|
||
| let bin_lower_price = | ||
| tick_to_spot(bin_lower_tick).expect(OVERFLOW_ERROR); | ||
| let bin_higher_price = | ||
| tick_to_spot(bin_higher_tick).expect(OVERFLOW_ERROR); | ||
|
|
||
| let bin_lower_price_sqrt = | ||
| bin_lower_price.checked_sqrt().expect(OVERFLOW_ERROR); | ||
| let bin_higher_price_sqrt = | ||
| bin_higher_price.checked_sqrt().expect(OVERFLOW_ERROR); | ||
|
|
||
| // Calculating the amount - we use min here so that if any loss | ||
| // of precision happens we do not end up exceeding the amount | ||
| // that we have in total. | ||
| let amount = min( | ||
| bin_higher_price_sqrt | ||
| .checked_sub(bin_lower_price_sqrt) | ||
| .and_then(|price_sqrt_difference| { | ||
| price_sqrt_difference.checked_mul(liquidity) | ||
| }) | ||
| .expect(OVERFLOW_ERROR), | ||
| remaining_y, | ||
| ); | ||
| remaining_y = | ||
| remaining_y.checked_sub(amount).expect(OVERFLOW_ERROR); | ||
|
|
||
| positions.push((bin_lower_tick, dec!(0), amount)); | ||
| } | ||
|
|
||
| // Finding the amount of X to contribute to each one of the higher | ||
| // bins (contain only X). | ||
| for bin_lower_tick in higher_ticks.iter().copied() { | ||
| let bin_higher_tick = | ||
| bin_lower_tick.checked_add(bin_span).expect(OVERFLOW_ERROR); | ||
|
|
||
| let bin_lower_price = | ||
| tick_to_spot(bin_lower_tick).expect(OVERFLOW_ERROR); | ||
| let bin_higher_price = | ||
| tick_to_spot(bin_higher_tick).expect(OVERFLOW_ERROR); | ||
|
|
||
| let bin_lower_price_sqrt = | ||
| bin_lower_price.checked_sqrt().expect(OVERFLOW_ERROR); | ||
| let bin_higher_price_sqrt = | ||
| bin_higher_price.checked_sqrt().expect(OVERFLOW_ERROR); | ||
|
|
||
| // Calculating the amount - we use min here so that if any loss | ||
| // of precision happens we do not end up exceeding the amount | ||
| // that we have in total. | ||
| let amount = min( | ||
| bin_higher_price_sqrt | ||
| .checked_sub(bin_lower_price_sqrt) | ||
| .and_then(|price_sqrt_difference| { | ||
| price_sqrt_difference.checked_mul(liquidity) | ||
| }) | ||
| .and_then(|nominator| { | ||
| let denominator = bin_lower_price_sqrt | ||
| .checked_mul(bin_higher_price_sqrt)?; | ||
|
|
||
| nominator.checked_div(denominator) | ||
| }) | ||
| .expect(OVERFLOW_ERROR), | ||
|
There was a problem hiding this comment. Any documentation for the division above? There was a problem hiding this comment. Yup, this is derived from the equation that I named We can modify the equation above and use it to find You can also find these equations here as equations 4 and 5. |
||
| remaining_x, | ||
| ); | ||
| remaining_x = | ||
| remaining_x.checked_sub(amount).expect(OVERFLOW_ERROR); | ||
|
|
||
| positions.push((bin_lower_tick, amount, dec!(0))); | ||
| } | ||
|
|
||
| let (receipt, change_x, change_y) = | ||
| pool.add_liquidity(bucket_x, bucket_y, positions); | ||
|
|
||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Do we have some visualization for curve
y = sqrt(tick_to_price(x + 1)) - sqrt(tick_to_price(x))? Trying to relate this to the triangular shape.There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I have graphed it out here: https://www.desmos.com/calculator/krrqdfifeg and here https://docs.google.com/spreadsheets/d/1LiD_XfjvgXuGStU2KPWhMJglLYYnuy6zJq2fgvg84Mg/edit?usp=sharing
Let me provide more context on the triangle shape and why it was chosen: Caviar based their calculations around the fact that at every price point along an
xy = kcurve thekis equal and doesn't change. So, they started with this premise and started working backwards to determine how much should be added to each bin such that thekin each bin is equal. They also used the fact that all bins at a lower price than the current price contain only Y and all bins above the current price contain only X.They chose an arbitrary
Kto be base their calculation on, let's say 500 and used the equations below to determine how much should each bin have:In the end, after calculating the amount they got that they should be a triangle.
I follow a very similar approach in the code here where the code doesn't actually say "get me a triangle formation", rather the code is contributing the amount of resources that we need to get an equal K in all of the bins and doesn't care what shape that gives us (but it results in a triangle as seen in the second link I shared above)