moved get_stableswap_bounds to StableswapConstraints

Author: poliwop

hydradx/model/solver/amm_constraints.py

@@ -179,3 +179,82 @@ def __init__(self, amm: Exchange):
         self.k = 2*(len(amm.asset_list) + 1) + self.auxiliary_ct
         self.shares = amm.shares
         self.liquidity = {tkn: amm.liquidity[tkn] for tkn in amm.asset_list}
+        self.ann = amm.ann
+        self.d = amm.d
+
+    def get_amm_bounds(self, approx: str, scaling: dict):
+        B = [0] + [scaling[tkn] for tkn in self.asset_list]
+        C = [scaling[self.tkn_share]]
+        ann = self.ann
+        s0 = self.shares
+        D0 = self.d
+        amm_i = self.amm_i
+        n_amm = len(self.asset_list) + 1
+        sum_assets = sum([self.liquidity[tkn] for tkn in self.asset_list])
+        # D0' = D_0 * (1 - 1/ann)
+        D0_prime = D0 * (1 - 1 / ann)
+        # a0 ~= -delta_s/s0 + [1 / (sum x_i^0 - D0') * sum delta_x_i - (D0'/s0) / (sum x_i^0 - D0') * delta_s]
+        denom = sum_assets - D0_prime
+        if approx[0] == "linear":
+            A = np.zeros((1, self.k))
+            A[0, amm_i.aux[0]] = 1  # a_{j,0} coefficient
+            A[0, amm_i.shares_net] = (1 + D0_prime / denom) * C[0] / s0  # delta_s coefficient
+            for t in range(1, n_amm):
+                A[0, amm_i.asset_net[t - 1]] = -B[t] / denom  # delta_x_i coefficient
+            b = np.array([0])
+            cones = [cb.ZeroConeT(1)]
+            cone_sizes = [1]
+        else:
+            A = np.zeros((3, self.k))
+            b = np.array([0, 0, 0])
+            # x = a_{j,0}
+            A[0, amm_i.aux[0]] = -1  # a_{j,0} coefficient
+            # y = 1 + C_jS_j / s_0
+            A[1, amm_i.shares_net] = -C[0] / s0  # delta_s coefficient
+            b[1] = 1
+            # z = An^n / D_0 sum(x_i^0 + B_i X_i) + (1 - An^n)(1 + C_jS_j / s_0)
+            A[2, amm_i.shares_net] = D0_prime * C[0] / denom / s0
+            for t in range(1, n_amm):
+                A[2, amm_i.asset_net[t - 1]] = -B[t] / denom
+            b[2] = 1
+            cones = [cb.ExponentialConeT()]
+            cone_sizes = [3]
+
+        for t in range(1, n_amm):
+            x0 = self.liquidity[self.asset_list[t - 1]]
+            if approx[t] == "linear":
+                A_t = np.zeros((1, self.k))
+                A_t[0, amm_i.aux[t]] = 1  # a_{j,t} coefficient
+                A_t[0, amm_i.shares_net] = C[0] / s0  # delta_s coefficient
+                A_t[0, amm_i.asset_net[t - 1]] = -B[t] / x0  # delta_x_i coefficient
+                b_t = np.array([0])
+                cone_t = cb.ZeroConeT(1)
+                cone_size_t = 1
+            else:
+                A_t = np.zeros((3, self.k))
+                b_t = np.zeros(3)
+                # x = a_{j,t}
+                A_t[0, amm_i.aux[t]] = -1
+                # y = 1 + C_jS_j / s_0
+                A_t[1, amm_i.shares_net] = -C[0] / s0
+                b_t[1] = 1
+                # z = (x_t^0 + B_t X_t) / D_0
+                A_t[2, amm_i.asset_net[t - 1]] = -B[t] / x0
+                b_t[2] = 1
+                cone_t = cb.ExponentialConeT()
+                cone_size_t = 3
+            cones.append(cone_t)
+            cone_sizes.append(cone_size_t)
+            A = np.vstack([A, A_t])
+            b = np.append(b, np.array(b_t))
+
+        A_final = np.zeros((1, self.k))
+        for t in range(n_amm):
+            A_final[0, amm_i.aux[t]] = -1
+        b_final = np.array([0])
+        A = np.vstack([A, A_final])
+        b = np.append(b, b_final)
+        cones.append(cb.NonnegativeConeT(1))
+        cone_sizes.append(1)
+
+        return A, b, cones, cone_sizes

hydradx/model/solver/omnix_solver.py

@@ -686,82 +686,6 @@ def _expand_submatrix(A, k: int, start: int):
     return A_limits_i
 
 
-def _get_stableswap_bounds(amm, amm_i: AmmIndexObject, approx, k, scaling):
-    B = [0] + [scaling[tkn] for tkn in amm.asset_list]
-    C = [scaling[amm.unique_id]]
-    ann = amm.ann
-    s0 = amm.shares
-    D0 = amm.d
-    n_amm = len(amm.asset_list) + 1
-    sum_assets = sum([amm.liquidity[tkn] for tkn in amm.asset_list])
-    # D0' = D_0 * (1 - 1/ann)
-    D0_prime = D0 * (1 - 1 / ann)
-    # a0 ~= -delta_s/s0 + [1 / (sum x_i^0 - D0') * sum delta_x_i - (D0'/s0) / (sum x_i^0 - D0') * delta_s]
-    denom = sum_assets - D0_prime
-    if approx[0] == "linear":
-        A5j = np.zeros((1, k))
-        A5j[0, amm_i.aux[0]] = 1  # a_{j,0} coefficient
-        A5j[0, amm_i.shares_net] = (1 + D0_prime / denom) * C[0] / s0  # delta_s coefficient
-        for t in range(1, n_amm):
-            A5j[0, amm_i.asset_net[t - 1]] = -B[t] / denom  # delta_x_i coefficient
-        b5j = np.array([0])
-        cones5j = [cb.ZeroConeT(1)]
-        cones_count5j = [1]
-    else:
-        A5j = np.zeros((3, k))
-        b5j = np.array([0, 0, 0])
-        # x = a_{j,0}
-        A5j[0, amm_i.aux[0]] = -1  # a_{j,0} coefficient
-        # y = 1 + C_jS_j / s_0
-        A5j[1, amm_i.shares_net] = -C[0] / s0  # delta_s coefficient
-        b5j[1] = 1
-        # z = An^n / D_0 sum(x_i^0 + B_i X_i) + (1 - An^n)(1 + C_jS_j / s_0)
-        A5j[2, amm_i.shares_net] = D0_prime * C[0] / denom / s0
-        for t in range(1, n_amm):
-            A5j[2, amm_i.asset_net[t - 1]] = -B[t] / denom
-        b5j[2] = 1
-        cones5j = [cb.ExponentialConeT()]
-        cones_count5j = [3]
-
-    for t in range(1, n_amm):
-        x0 = amm.liquidity[amm.asset_list[t - 1]]
-        if approx[t] == "linear":
-            A5jt = np.zeros((1, k))
-            A5jt[0, amm_i.aux[t]] = 1  # a_{j,t} coefficient
-            A5jt[0, amm_i.shares_net] = C[0] / s0  # delta_s coefficient
-            A5jt[0, amm_i.asset_net[t - 1]] = -B[t] / x0  # delta_x_i coefficient
-            b5jt = np.array([0])
-            cone5jt = cb.ZeroConeT(1)
-            cone_count5jt = 1
-        else:
-            A5jt = np.zeros((3, k))
-            b5jt = np.zeros(3)
-            # x = a_{j,t}
-            A5jt[0, amm_i.aux[t]] = -1
-            # y = 1 + C_jS_j / s_0
-            A5jt[1, amm_i.shares_net] = -C[0] / s0
-            b5jt[1] = 1
-            # z = (x_t^0 + B_t X_t) / D_0
-            A5jt[2, amm_i.asset_net[t - 1]] = -B[t] / x0
-            b5jt[2] = 1
-            cone5jt = cb.ExponentialConeT()
-            cone_count5jt = 3
-        cones5j.append(cone5jt)
-        cones_count5j.append(cone_count5jt)
-        A5j = np.vstack([A5j, A5jt])
-        b5j = np.append(b5j, np.array(b5jt))
-
-    A5j_final = np.zeros((1, k))
-    for t in range(n_amm):
-        A5j_final[0, amm_i.aux[t]] = -1
-    b5j_final = np.array([0])
-    A5j = np.vstack([A5j, A5j_final])
-    b5j = np.append(b5j, b5j_final)
-    cones5j.append(cb.NonnegativeConeT(1))
-    cones_count5j.append(1)
-
-    return A5j, b5j, cones5j, cones_count5j
-
 def _get_amm_bounds(p, indices_to_keep=None):
     # CFMM invariants must be respected
     n, u, m, N = p.n, p.u, p.m, p.N
@@ -772,16 +696,10 @@ def _get_amm_bounds(p, indices_to_keep=None):
     cones5 = []
     cones_count5 = []
     for j, amm in enumerate(p.amm_list):
-        amm_i = p.amm_i[j]
         amm_constraints = p.amm_constraints[j]
         approx = p.get_amm_approx(j)
-        if isinstance(amm, StableSwapPoolState):
-            A5j, b5j, cones5j, cones_count5j = _get_stableswap_bounds(amm, amm_i, approx, k, p._scaling)
-        elif isinstance(amm, ConstantProductPoolState):
-            A5j_small, b5j, cones5j, cones_count5j = amm_constraints.get_amm_bounds(approx, p._scaling)
-            A5j = _expand_submatrix(A5j_small, k, p.amm_i[j].shares_net)
-        else:
-            raise AssertionError("Unrecognized AMM type")
+        A5j_small, b5j, cones5j, cones_count5j = amm_constraints.get_amm_bounds(approx, p._scaling)
+        A5j = _expand_submatrix(A5j_small, k, p.amm_i[j].shares_net)
         A5 = np.vstack([A5, A5j])
         b5 = np.concatenate([b5, b5j])
         cones5 = cones5 + cones5j

hydradx/tests/test_solver/test_amm_constraints.py

@@ -233,3 +233,47 @@ def test_get_xyk_bounds():
     s = b - A @ x
     if check_all_cone_feasibility(s, cones, cones_sizes, tol=0):
         raise AssertionError("Cone feasibility check should fail")
+
+
+# TODO test with auxiliary variable calculation
+# def test_get_stableswap_bounds():
+#     amm = StableSwapPoolState(tokens={"A": 1_000_000, "B": 2_000_000}, amplification=100)
+#     constraints = StableswapConstraints(amm)
+#     scaling = {tkn: 1 for tkn in (amm.asset_list + [amm.unique_id])}
+#     amm_i = constraints.amm_i
+#
+#     for approx in ["Linear", "None"]:
+#         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 Stableswap 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 5 A for 1 B should work
+#         a_sell_amt, b_buy_amt = 5, 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 5 A should not work
+#         b_sell_amt, a_buy_amt = 1, 5
+#         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")

hydradx/tests/test_solver/test_solver.py

@@ -3,7 +3,7 @@
 import random
 
 import pytest
-from hypothesis import given, strategies as st, settings, Verbosity, Phase
+from hypothesis import given, strategies as st, settings, Verbosity, Phase, reproduce_failure
 
 from hydradx.model.amm.agents import Agent
 from hydradx.model.amm.omnipool_amm import OmnipoolState
@@ -343,9 +343,7 @@ def test_no_intent_arbitrage_stableswap_xyk_feeless(ratio):
     initial_state = OmnipoolState(tokens={tkn: {'liquidity': liquidity[tkn], 'LRNA': lrna[tkn]} for tkn in lrna})
 
     sp_tokens = {"USDT": 7600000, "USDC": 9200000}
-    stablepool = StableSwapPoolState(
-        tokens=sp_tokens, amplification=1000, unique_id="2-Pool"
-    )
+    stablepool = StableSwapPoolState(tokens=sp_tokens, amplification=1000, unique_id="2-Pool")
 
     xyk = ConstantProductPoolState(
         tokens={
@@ -360,24 +358,34 @@ def test_no_intent_arbitrage_stableswap_xyk_feeless(ratio):
     orig_op_price = initial_state.price( "DOT", "2-Pool") * stablepool.share_price("USDT")
     orig_xyk_price = xyk.liquidity['USDT'] / xyk.liquidity['DOT']
     max_delta = float('inf')
-    while max_delta > 0:
+    for i in range(100):
         x = find_solution_outer_approx(initial_state, intents, amm_list)
 
         agent = Agent(enforce_holdings=False)
         if x['amm_deltas'][1][1] >= 0:  # XYK pool is in index 1
-            assert x['amm_deltas'][1][2] <= 0  # DOT bought from XYK
-            xyk.swap(agent, tkn_sell = "USDT", tkn_buy = "DOT", sell_quantity = x['amm_deltas'][1][1])
-            initial_state.swap(agent, tkn_buy = "2-Pool", tkn_sell = "DOT", sell_quantity = agent.get_holdings("DOT"))
-            stablepool.remove_liquidity(agent, agent.get_holdings("2-Pool"), "USDT")
+            if x['amm_deltas'][1][2] >= 0:  # both deltas with same sign indicates rounding issues
+                if x['amm_deltas'][1][2] / xyk.liquidity['DOT'] >= 0.0001:
+                    raise AssertionError("XYK pool should not be buying DOT")
+                x['amm_deltas'] = [[0]]
+            else:
+                xyk.swap(agent, tkn_sell = "USDT", tkn_buy = "DOT", sell_quantity = x['amm_deltas'][1][1])
+                initial_state.swap(agent, tkn_buy = "2-Pool", tkn_sell = "DOT", sell_quantity = agent.get_holdings("DOT"))
+                stablepool.remove_liquidity(agent, agent.get_holdings("2-Pool"), "USDT")
         else:
-            assert x['amm_deltas'][1][2] >= 0  # DOT sold to AMM
-            xyk.swap(agent, tkn_sell="DOT", tkn_buy="USDT", sell_quantity=x['amm_deltas'][1][2])
-            stablepool.add_liquidity(agent, agent.get_holdings("USDT"), "USDT")
-            initial_state.swap(agent, tkn_buy="DOT", tkn_sell="2-Pool", sell_quantity=agent.get_holdings("2-Pool"))
+            if x['amm_deltas'][1][2] < 0:
+                if x['amm_deltas'][1][2] / xyk.liquidity['DOT'] <= -0.0001:
+                    raise AssertionError("XYK pool should not be selling DOT")
+                x['amm_deltas'] = [[0]]
+            else:
+                xyk.swap(agent, tkn_sell="DOT", tkn_buy="USDT", sell_quantity=x['amm_deltas'][1][2])
+                stablepool.add_liquidity(agent, agent.get_holdings("USDT"), "USDT")
+                initial_state.swap(agent, tkn_buy="DOT", tkn_sell="2-Pool", sell_quantity=agent.get_holdings("2-Pool"))
 
         op_price = initial_state.price( "DOT", "2-Pool") * stablepool.share_price("USDT")
         xyk_price = xyk.liquidity['USDT'] / xyk.liquidity['DOT']
         max_delta = max([max(y) for y in x['amm_deltas']])
+        if max_delta <= 0:
+            break
     if abs((op_price - xyk_price) / op_price) >= 0.005:
         raise AssertionError("XYK price should be close to Omnipool price")