Added linear approximation for XYK pools

Author: poliwop

hydradx/model/solver/amm_constraints.py

@@ -179,34 +179,35 @@ def __init__(self, amm: ConstantProductPoolState):
         self.liquidity = {tkn: amm.liquidity[tkn] for tkn in amm.asset_list}
 
     def get_amm_bounds(self, approx: str, scaling: dict) -> tuple:
-        # TODO implement linear, quadratic approximations
         amm_i = self.amm_i
         coef = [scaling[self.tkn_share] / self.shares] + [scaling[tkn] / self.liquidity[tkn] for tkn in self.asset_list]
-        # if approx == "linear":  # linearize the AMM constraint
-        #     c1 = 1 / (1 + epsilon_tkn[tkn])
-        #     c2 = 1 / (1 - epsilon_tkn[tkn]) if epsilon_tkn[tkn] < 1 else 1e15
-        #     A5j2 = np.zeros((2, k))
-        #     b5j2 = np.zeros(2)
-        #     A5j2[0, amm_i.asset_net[0]] = -B[1]
-        #     A5j2[0, amm_i.asset_net[1]] = -B[2] * c1
-        #     A5j2[1, amm_i.asset_net[0]] = -B[1]
-        #     A5j2[1, amm_i.asset_net[1]] = -B[2] * c2
-        #     cones5j.append(cb.NonnegativeConeT(2))
-        #     cones_count5j.append(2)
-        # else:  # full constraint
-        #     A5j2 = np.zeros((3, k))
-        #     b5j2 = np.ones(3)
-        #     A5j2[0, amm_i.asset_net[0]] = -B[1]
-        #     A5j2[1, amm_i.asset_net[1]] = -B[2]
-        #     cones5j.append(cb.PowerConeT(0.5))
-        #     cones_count5j.append(3)
-        A = np.zeros((3, self.k))
-        b = np.ones(3)
-        A[0, amm_i.asset_net[0]] = -coef[1]
-        A[1, amm_i.asset_net[1]] = -coef[2]
-        A[2, amm_i.shares_net] = -coef[0]
-        cones = [cb.PowerConeT(0.5)]
-        cone_sizes = [3]
+        epsilon = 1e-6  # largest delta/balance for which we still use linear approximation
+        if approx == "linear":  # linearize the AMM constraint
+            A = np.zeros((6, self.k))
+            b = np.zeros((6))
+            cones = [cb.NonnegativeConeT(6)]
+            cone_sizes = [6]
+            share_cs = [coef[0] * (2 - coef[0] * epsilon), coef[0] * (2 + coef[0] * epsilon)]
+            asset_cs = [
+                [-coef[1], -coef[2]],
+                [-coef[1], -coef[2] * (1 + epsilon * coef[1])],
+                [-coef[1] * (1 + epsilon * coef[2]), -coef[2]]
+            ]
+            row = 0
+            for share_c in share_cs:
+                for asset_c in asset_cs:
+                    A[row, amm_i.shares_net] = share_c
+                    A[row, amm_i.asset_net[0]] = asset_c[0]
+                    A[row, amm_i.asset_net[1]] = asset_c[1]
+                    row += 1
+        else:  # full constraint
+            A = np.zeros((3, self.k))
+            b = np.ones(3)
+            A[0, amm_i.asset_net[0]] = -coef[1]
+            A[1, amm_i.asset_net[1]] = -coef[2]
+            A[2, amm_i.shares_net] = -coef[0]
+            cones = [cb.PowerConeT(0.5)]
+            cone_sizes = [3]
 
         return A, b, cones, cone_sizes
 
@@ -253,7 +254,7 @@ def get_linearized_amm_constraints(self, x_list, global_asset_list: list, scalin
     def get_approx(self, deltas: list) -> str:
         pcts = [abs(deltas[0]) / self.shares]  # first shares size constraint, delta_s / s_0 <= epsilon
         pcts.extend([abs(deltas[j + 1]) / self.liquidity[tkn] for j, tkn in enumerate(self.asset_list)])
-        approx = "linear" if max(pcts) <= 1e-5 else "full"
+        approx = "linear" if max(pcts) <= 1e-6 else "full"
         return approx
 
     def upgrade_approx(self, deltas: list, current_approx: str) -> str:

hydradx/tests/test_solver/test_amm_constraints.py

@@ -199,40 +199,41 @@ def test_get_xyk_bounds():
     scaling = {tkn: 1 for tkn in (amm.asset_list + [amm.unique_id])}
     amm_i = constraints.amm_i
 
-    A, b, cones, cones_sizes = constraints.get_amm_bounds("None", scaling)
-    x = np.zeros(constraints.k)
-    # selling 5 B for 1 A should work
-    b_sell_amt, a_buy_amt = 5, 1
-    x[amm_i.asset_net[0]] = -a_buy_amt
-    x[amm_i.asset_net[1]] = b_sell_amt
-    x[amm_i.asset_out[0]] = a_buy_amt
-    s = b - A @ x
-    if not check_all_cone_feasibility(s, cones, cones_sizes, tol=0):
-        raise AssertionError("Cone feasibility check failed for valid XYK bounds")
-    # selling 1 A for 1 5 should not work
-    a_sell_amt, b_buy_amt = 1, 5
-    x[amm_i.asset_net[1]] = -b_buy_amt
-    x[amm_i.asset_net[0]] = a_sell_amt
-    x[amm_i.asset_out[1]] = b_buy_amt
-    s = b - A @ x
-    if check_all_cone_feasibility(s, cones, cones_sizes, tol=0):
-        raise AssertionError("Cone feasibility check should fail")
-    # selling 1 A for 1 B should work
-    a_sell_amt, b_buy_amt = 1, 1
-    x[amm_i.asset_net[1]] = -b_buy_amt
-    x[amm_i.asset_net[0]] = a_sell_amt
-    x[amm_i.asset_out[1]] = b_buy_amt
-    s = b - A @ x
-    if not check_all_cone_feasibility(s, cones, cones_sizes, tol=0):
-        raise AssertionError("Cone feasibility check should succeed")
-    # selling 1 B for 1 A should not work
-    b_sell_amt, a_buy_amt = 1, 1
-    x[amm_i.asset_net[0]] = -a_buy_amt
-    x[amm_i.asset_net[1]] = b_sell_amt
-    x[amm_i.asset_out[0]] = a_buy_amt
-    s = b - A @ x
-    if check_all_cone_feasibility(s, cones, cones_sizes, tol=0):
-        raise AssertionError("Cone feasibility check should fail")
+    for approx in ["none", "linear"]:  # mult = 10 should test full approximation, 0.1 should test linear approximation
+        A, b, cones, cones_sizes = constraints.get_amm_bounds(approx, scaling)
+        x = np.zeros(constraints.k)
+        # selling 5 B for 1 A should work
+        b_sell_amt, a_buy_amt = 5, 1
+        x[amm_i.asset_net[0]] = -a_buy_amt
+        x[amm_i.asset_net[1]] = b_sell_amt
+        x[amm_i.asset_out[0]] = a_buy_amt
+        s = b - A @ x
+        if not check_all_cone_feasibility(s, cones, cones_sizes, tol=0):
+            raise AssertionError("Cone feasibility check failed for valid XYK bounds")
+        # selling 1 A for 1 5 should not work
+        a_sell_amt, b_buy_amt = 1, 5
+        x[amm_i.asset_net[1]] = -b_buy_amt
+        x[amm_i.asset_net[0]] = a_sell_amt
+        x[amm_i.asset_out[1]] = b_buy_amt
+        s = b - A @ x
+        if check_all_cone_feasibility(s, cones, cones_sizes, tol=0):
+            raise AssertionError("Cone feasibility check should fail")
+        # selling 1 A for 1 B should work
+        a_sell_amt, b_buy_amt = 1, 1
+        x[amm_i.asset_net[1]] = -b_buy_amt
+        x[amm_i.asset_net[0]] = a_sell_amt
+        x[amm_i.asset_out[1]] = b_buy_amt
+        s = b - A @ x
+        if not check_all_cone_feasibility(s, cones, cones_sizes, tol=0):
+            raise AssertionError("Cone feasibility check should succeed")
+        # selling 1 B for 1 A should not work
+        b_sell_amt, a_buy_amt = 1, 1
+        x[amm_i.asset_net[0]] = -a_buy_amt
+        x[amm_i.asset_net[1]] = b_sell_amt
+        x[amm_i.asset_out[0]] = a_buy_amt
+        s = b - A @ x
+        if check_all_cone_feasibility(s, cones, cones_sizes, tol=0):
+            raise AssertionError("Cone feasibility check should fail")
 
 
 def test_xyk_upgrade_approx():
@@ -273,11 +274,11 @@ def test_stableswap_upgrade_approx():
     # current_approx is entirely linear
     current_approx = ["linear", "linear", "linear"]
     examples = [  # [delta_mults, expected_approx]
-        [[1e-4, 1e-6, 1e-6], ["full", "linear", "linear"]],
-        [[1e-6, 1e-4, 1e-6], ["full", "full", "linear"]],
-        [[1e-6, 1e-6, 1e-4], ["full", "linear", "full"]],
+        [[1e-4, 1e-7, 1e-7], ["full", "linear", "linear"]],
+        [[1e-7, 1e-4, 1e-7], ["full", "full", "linear"]],
+        [[1e-7, 1e-6, 1e-4], ["full", "linear", "full"]],
         [[1e-4, 1e-4, 1e-4], ["full", "full", "full"]],
-        [[1e-6, 1e-6, 1e-6], ["linear", "linear", "linear"]]
+        [[1e-7, 1e-7, 1e-7], ["linear", "linear", "linear"]]
     ]
     for delta_mults, expected_approx in examples:
         deltas = [amm.shares * delta_mults[0], amm.liquidity["A"] * delta_mults[1], amm.liquidity["B"] * delta_mults[2]]
@@ -289,11 +290,11 @@ def test_stableswap_upgrade_approx():
     # current_approx is mixed
     current_approx = ["full", "linear", "full"]
     examples = [  # [delta_mults, expected_approx]
-        [[1e-4, 1e-6, 1e-6], ["full", "linear", "full"]],
-        [[1e-6, 1e-4, 1e-6], ["full", "full", "full"]],
-        [[1e-6, 1e-6, 1e-4], ["full", "linear", "full"]],
+        [[1e-4, 1e-7, 1e-7], ["full", "linear", "full"]],
+        [[1e-7, 1e-4, 1e-7], ["full", "full", "full"]],
+        [[1e-7, 1e-7, 1e-4], ["full", "linear", "full"]],
         [[1e-4, 1e-4, 1e-4], ["full", "full", "full"]],
-        [[1e-6, 1e-6, 1e-6], ["full", "linear", "full"]]
+        [[1e-7, 1e-7, 1e-7], ["full", "linear", "full"]]
     ]
     for delta_mults, expected_approx in examples:
         deltas = [amm.shares * delta_mults[0], amm.liquidity["A"] * delta_mults[1], amm.liquidity["B"] * delta_mults[2]]

hydradx/tests/test_solver/test_solver.py

@@ -16,6 +16,9 @@
 from hydradx.model.amm.stableswap_amm import StableSwapPoolState
 from hydradx.model.amm.xyk_amm import ConstantProductPoolState
 
+settings.register_profile("ci", deadline=None, print_blob=True)
+settings.load_profile("ci")
+
 
 ##################################
 # Functional tests #
@@ -855,7 +858,7 @@ def test_matching_trades_execute_more_full_execution():
 ###############
 # Other tests #
 ###############
-
+@reproduce_failure('6.127.0', b'ACg/dZBsfh29sA==')
 @given(st.floats(min_value=1e-7, max_value=0.01))
 @settings(verbosity=Verbosity.verbose, print_blob=True)
 def test_fuzz_single_trade_settles(size_factor: float):