initial import

Author: atiselsts

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Atis Elsts
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,24 @@
+# Code for the Uniswap LP Articles
+
+This repository contains Python code for the artice series ["Liquidity Provider Strategies for Uniswap v3"](https://atise.medium.com/liquidity-provider-strategies-for-uniswap-v3-table-of-contents-64725c6c0b10).
+
+The code is used to produce the graphs in the published articles.
+
+For visualization, it uses Matplotlib in combination with the [ING theme](https://pypi.org/project/ing-theme-matplotlib/).
+
+# Contents
+
+* v2_math.py - math for full-range positions
+* v3_math.py - math for concentrated liquidity positions
+* plot_article_1.py - plots for the article "An Introduction to Uniswap LP Strategies and Hedging"
+* plot_article_2.py - plots for the article "Dynamic Hedging"
+* plot_article_3.py - plots for the article "Loss Versus Rebalancing (LVR)"
+* plot_article_4.py - plots for the article "Power Perpetuals"
+* plot_article_6.py - plots for the article "Liquidity Relocation (Rebalancing)"
+* fit_power_perpetual_coefficients.py - code from the power perpetual article exported to a standalone module
+
+# Simulations
+
+The current implementation of price path simulations use significant RAM
+and require several minutes to complete. They could be improved by using the JIT
+decorator, or by rewriting the code to a faster programming language.

fit_power_perpetual_coefficients.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python
+
+#
+# This script computes the power perpetual coefficients required to hedge
+# a v3 concentrated liquidity coeffcient.
+# The inspiration comes from the article "Spanning with Power Perpetuals" by J. Clarke.
+#
+
+import matplotlib.pyplot as pl
+import numpy as np
+from ing_theme_matplotlib import mpl_style
+import v2_math
+import v3_math
+
+# max order to use for the power perp
+MAX_ORDER = 2
+
+# the higher, the more accurate the fit
+NUM_STEPS = 1000
+
+INITIAL_PRICE = 100
+INITIAL_VALUE = 200
+
+#
+# This uses hedging formula from the article "Spanning with Power Perpetuals" by Joseph Clark,
+# where the AMM is approximated using the Taylor expansion around r=0.
+#
+# This assumes zero funding rate! (as time is not given as a parameter to this function)
+#
+def power_perp_v2(initial_value, initial_price, price, order, include_first_order=True):
+    r = price / initial_price - 1.0 # r is the price return
+    perp_return = 0
+    if order >= 1 and include_first_order:
+        perp_return += -0.5 * r
+    if order >= 2:
+        perp_return += 0.125 * (r ** 2)
+    if order >= 3:
+        perp_return += -3 / 48 * (r ** 3)
+    if order >= 4:
+        perp_return += 15 / 384 * (r ** 4)
+    perp_value = initial_value * (perp_return + 1.0)
+    #    print("power perp value at price", order, include_first_order, price, perp_value)
+    return perp_value
+
+#
+# This uses numerically found coefficient array for a narrow-range v3 positions.
+#
+def power_perp_v3(initial_value, initial_price, price, price_a, price_b, coefficients, order, include_first_order=True):
+    # assume that when the price crosses the LP range boundaries, the owner sells the power perp,
+    # effectively implying that the price can never go out of boundaries.
+    price = min(price, price_b)
+    price = max(price, price_a)
+
+    r = price / initial_price - 1.0 # r is the price return
+    perp_return = 0
+    if order >= 1 and include_first_order:
+        perp_return += coefficients[1] * r
+    if order >= 2:
+        perp_return += coefficients[2] * (r ** 2)
+    if order >= 3:
+        perp_return += coefficients[3] * (r ** 3)
+    if order >= 4:
+        perp_return += coefficients[4] * (r ** 4)
+
+    perp_value = initial_value * (perp_return + 1.0)
+    #    print("power perp value at price", order, include_first_order, price, perp_value)
+    if perp_value < 0:
+        perp_value = 0
+    return perp_value
+
+
+#
+# Returns coefficients of the power perpetual needed to hedge a given position.
+#
+# Negative coefficient means that the perp should be short, positive: long.
+# The coefficient are in terms of the initial value of the LP position.
+#
+# For instance, if the function returns [0, -0.5, 0.125, -0.0625, 0.0390625],
+# (these are the coefficients for a full-range position)
+# the ETH/USD LP should:
+# 1. Buy short ETH perp worth 50% of the position.
+# 2. Buy long ETH^2 perp worth 12.5% of the position.
+# 3. (Optionally) Buy short ETH^3 perp worth 6.25% of the position.
+# 4. (Optionally) Buy long ETH^4 perp worth ~3.9% of the position.
+#
+#
+# Example n-th order reconstructions from the result:
+#
+# coefficients = fit_power_hedging_coefficients(L, p_a, p_b)
+# reconstruction1 = [power_perp_v3(price, coefficients, 1) for price in x]
+# reconstruction2 = [power_perp_v3(price, coefficients, 2) for price in x]
+# reconstruction3 = [power_perp_v3(price, coefficients, 3) for price in x]
+#
+def fit_power_hedging_coefficients(liquidity, price_a, price_b, max_order):
+    # the max value is bounded by the amount of tokens `y` at price `price_b`
+    v_max = liquidity * (price_b ** 0.5 - price_a ** 0.5)
+
+    step = (price_b - price_a) / NUM_STEPS
+
+    prices = np.arange(price_a, price_b + step, step)
+    values = [v3_math.position_value_from_max_value(v_max, price, price_a, price_b) for price in prices]
+
+    # convert from f(x) to f(r) before doing the fit
+    price_returns = [price / INITIAL_PRICE - 1.0 for price in prices]
+    value_returns = [v / INITIAL_VALUE - 1.0 for v in values]
+
+    # do a polynomial fit, with a high-order polynomial
+    assert max_order < 20
+    polyfit_many = np.polyfit(price_returns, value_returns, 20)
+
+    # use just the first N coefficients from the result
+    coefficients = [0] * (max_order + 1)
+    coefficients[0] = 0 # always zero for the 0-th order hedge
+    for i in range(1, max_order + 1):
+        coefficients[i] = -polyfit_many[-(i + 1)] # i-th order power perp
+
+    return coefficients
+
+    
+def main():
+    mpl_style(True)
+
+    # max order of the power perp
+    order = MAX_ORDER
+
+    # Full range positions
+    min_price = INITIAL_PRICE / 4
+    max_price = INITIAL_PRICE * 4
+    step = (max_price - min_price) / NUM_STEPS
+    prices = np.arange(min_price, max_price + step, step)
+    liquidity = v2_math.get_liquidity(INITIAL_VALUE / INITIAL_PRICE / 2, INITIAL_VALUE / 2)
+    pl.figure()
+    profit_pos = [v2_math.position_value_from_liquidity(liquidity, price) - INITIAL_VALUE for price in prices]
+    pl.plot(prices, profit_pos, label="LP position")
+    profit_perp = [power_perp_v2(INITIAL_VALUE, INITIAL_PRICE, price, order) - INITIAL_VALUE for price in prices]
+    pl.plot(prices, profit_perp, label=f"Power perperpetual, order={order}")
+    pl.plot(prices, [a+b for a,b in zip(profit_perp, profit_pos)], label="Hedged position")
+
+    pl.xlabel("Volatile asset price, $")
+    pl.ylabel("Profit, $")
+    pl.title("Full range")
+    pl.legend()
+    pl.show()
+    pl.close()
+
+
+    # Concentrated liquidity positions with different range r
+    for r in [1.01, 1.1, 1.5, 2.0]:
+        for skew in [-1, 0, +1]:
+            r_low = r_high = r
+            if skew < 0:
+                r_low = r_low ** 2
+            elif skew > 0:
+                r_high = r_high ** 2
+            price_a = INITIAL_PRICE / r_low
+            price_b = INITIAL_PRICE * r_high
+            liquidity = v3_math.position_liquidity_from_value(
+                INITIAL_VALUE, INITIAL_PRICE, price_a, price_b)
+
+            # check that the liquidity/value math is correct
+            v_test = v3_math.position_value_from_liquidity(
+                liquidity, INITIAL_PRICE, price_a, price_b)
+            assert v_test - 1e-8 < INITIAL_VALUE < v_test + 1e-8
+
+            # get the hedging power perp coefficients
+            coefficients = fit_power_hedging_coefficients(liquidity, price_a, price_b, order)
+
+            min_price = price_a / (r ** 0.5)
+            max_price = price_b * (r ** 0.5)
+            step = (max_price - min_price) / NUM_STEPS
+            prices = np.arange(min_price, max_price + step, step)
+            pl.figure()
+
+            profit_pos = [v3_math.position_value_from_liquidity(
+                liquidity, price, price_a, price_b) - INITIAL_VALUE for price in prices]
+            pl.plot(prices, profit_pos, label="LP position")
+            profit_perp = [power_perp_v3(INITIAL_VALUE, INITIAL_PRICE, price, price_a, price_b,
+                                         coefficients, order) - INITIAL_VALUE for price in prices]
+            pl.plot(prices, profit_perp, label=f"Power perp, order={order}")
+            pl.plot(prices, [a+b for a,b in zip(profit_perp, profit_pos)], label="Hedged position")
+
+            pl.title(f"range=[{price_a:.1f} {price_b:.1f}]")
+            pl.legend()
+            pl.show()
+            pl.close()
+
+if __name__ == '__main__':
+    main()
+    print("all done!")