feat: xcp_profit up-only (#131)

* feat: xcp_profit up-only

* test: rm xcpx from stateful tests

Author: heswithme

contracts/main/Twocrypto.vy

@@ -206,6 +206,7 @@ balances: public(uint256[N_COINS])
 D: public(uint256)
 xcp_profit: public(uint256)
 xcp_profit_a: public(uint256)  # <--- Full profit at last claim of admin fees.
+admin_claimed_profit: public(uint256)  # Cumulative admin extraction from LP+DAO bucket, in vp units.
 
 virtual_price: public(uint256)  # <------ Cached (fast to read) virtual price.
 #                          The cached `virtual_price` is also used internally.
@@ -680,6 +681,7 @@ def add_liquidity(
         self.virtual_price = 10**18
         self.xcp_profit = 10**18
         self.xcp_profit_a = 10**18
+        self.admin_claimed_profit = 0
 
         self.mint(receiver, d_token)
     assert d_token >= min_mint_amount, "slippage"
@@ -1152,9 +1154,21 @@ def tweak_price(
     # 1. xcp_profit grows after virtual price, total growth since launch = (xcp_profit − 1)
     # 2. We reserve lp_profit_fraction of the growth for LPs and admin, rest is used to rebalance the pool
 
-    # Rebalancing condition transformation:
-    # virtual_price > 1 + (xcp_profit - 1) * lp_profit_fraction
-    threshold_vp: uint256 = PRECISION + (max(xcp_profit, PRECISION) - PRECISION) * self.lp_profit_fraction // FEE_PRECISION
+    # Rebalancing condition basis:
+    #   virtual_price > 1 + (xcp_profit - 1) * lp_profit_fraction - admin_claimed_profit
+    #                  |         pre_admin_threshold_vp          |
+    # Interpretation:
+    #   1. xcp_profit - 1 is total gross profit growth above baseline.
+    #   2. Multiplying by lp_profit_fraction keeps only the LP+DAO retained share.
+    #   3. admin_claimed_profit subtracts what the admin has already extracted from that bucket.
+    #   4. The threshold is floored at PRECISION.
+    pre_admin_threshold_vp: uint256 = PRECISION + (
+        unsafe_sub(max(xcp_profit, PRECISION), PRECISION) * self.lp_profit_fraction // FEE_PRECISION
+    )
+    threshold_vp: uint256 = max(
+        PRECISION,
+        pre_admin_threshold_vp - min(self.admin_claimed_profit, pre_admin_threshold_vp),
+    )
     # user_supply < total_supply => vp_boosted > virtual_price
     # by not accounting for donation shares, virtual_price is boosted leading to rebalance trigger
     # this is approximate condition that preliminary indicates readiness for rebalancing
@@ -1370,34 +1384,22 @@ def _claim_admin_fees():
     )
 
     if fees > 0:
-        # -------------------- Recalculate virtual price and xcp_profit ----------
+        # ---------------- Recalculate virtual price and admin claim offset -------
         # We withdraw token balances without touching LP shares, so virtual price goes down.
         updated_vprice: uint256 = current_vprice - fees
         # Do not claim fees if doing so causes virtual price to drop below 10**18.
         if updated_vprice < 10**18:
             return
-        # To maintain rebalancing condition vp' > 1 + (xcp_profit' - 1)*lpf:
-        # (i.e. not to affect rebalancing invariant)
-        # at the boundary:
-        #       vp - f = 1 + (xcp_profit - 1)*lpf - f
-        #       vp - f = 1 + (xcp_profit - 1 - f/lpf)*lpf
-        #    => xcp_profit' := xcp_profit - f / lpf
-        xcp_profit -= fees * FEE_PRECISION // lp_profit_fraction # (fees>0 => lpf>0)
-
-        # Another way to see this is to track total_admin_claimed (sum_i(fees)), the cumulative amount
-        # extracted from the LP+DAO bucket, and compare virtual_price against
-        # 1 + (xcp_profit - 1) * lpf - total_admin_claimed instead.
-        # This alternative model would keep xcp_profit strictly increasing.
-        # Instead we fold claimed profit directly into xcp_profit here.
-
-        # xcp_profit as raw value is thus shouldn't be used in integrations!
+        # Keep xcp_profit as the gross profit signal and track claimed admin
+        # extraction separately in the same virtual-price units as `fees`.
+        # Rebalancing thresholding then compares virtual_price against:
+        #   1 + (xcp_profit - 1) * lpf - admin_claimed_profit
+        self.admin_claimed_profit += fees
 
         # ---------------------------- Update State ------------------------------
         self.virtual_price = updated_vprice
-        self.xcp_profit = xcp_profit
         self.last_admin_fee_claim_timestamp = block.timestamp
-        if xcp_profit > xcp_profit_a:
-            self.xcp_profit_a = xcp_profit  # <-------- Cache last claimed profit.
+        self.xcp_profit_a = xcp_profit  # <-------- Cache last claimed gross profit.
 
         # Adjust D after admin removes liquidity
         # no _get_D() because we can't claim during ramping

tests/stateful/stateful_base.py

@@ -25,7 +25,6 @@ class StatefulBase(RuleBasedStateMachine):
     decimals = None
     xcp_profit = 0
     xcp_profit_a = 0
-    xcpx = 0
     depositors = None
     equilibrium = 0
     swapped_once = False
@@ -80,7 +79,6 @@ def donations_as_user():
         # initial profit is 1e18
         self.xcp_profit = 1e18
         self.xcp_profit_a = 1e18
-        self.xcpx = 1e18
 
         self.depositors = set()
 
@@ -605,28 +603,12 @@ def virtual_price(self):
 
     @invariant()
     def up_only_profit(self):
-        """This method checks if the pool is profitable, since it should
-        never lose money.
-
-        To do so we use the so called `xcpx`. This is an empirical measure
-        of profit that is even stronger than `xcp`. We have to use this
-        because `xcp` goes down when claiming admin fees.
-
-        You can imagine `xcpx` as a value that that is always between the
-        interval [xcp_profit, xcp_profit_a]. When `xcp` goes down
-        when claiming fees, `xcp_a` goes up. Averaging them creates this
-        measure of profit that only goes down when something went wrong.
-        """
+        """Profit should be monotone outside ramping."""
         xcp_profit = self.pool.xcp_profit()
-        xcp_profit_a = self.pool.xcp_profit_a()
-        xcpx = (xcp_profit + xcp_profit_a + 1e18) // 2
 
-        # make sure that the previous profit is smaller than the current
-        assert xcpx >= self.xcpx, "xcpx has decreased"
-        # updates the previous profits
-        self.xcpx = xcpx
+        assert xcp_profit >= self.xcp_profit, "xcp_profit has decreased"
         self.xcp_profit = xcp_profit
-        self.xcp_profit_a = xcp_profit_a
+        self.xcp_profit_a = self.pool.xcp_profit_a()
 
 
 TestBase = StatefulBase.TestCase

tests/stateful/test_stateful.py

@@ -252,7 +252,7 @@ def can_always_withdraw(self, imbalanced_operations_allowed=True):
     def virtual_price(self):
         # we disable this invariant because claiming admin fees can break it.
         # claiming admin_fees can lead to a decrease in the virtual price
-        # however the pool is still profitable as long as xcpx is increasing.
+        # while xcp_profit remains monotone in the non-ramping model.
         pass
 
 

tests/unitary/pool/test_claim_admin_fees.py

@@ -173,6 +173,9 @@ def test_claim_no_rebalancing(gm_pool, fee_receiver):
     balance_pool(pool_instance)
 
     pool_values_post = coin0_values(pool_instance, pool_instance.address)
+    xcp_profit_pre_claim = pool_instance.xcp_profit()
+    xcp_profit_a_pre_claim = pool_instance.xcp_profit_a()
+    admin_claimed_profit_pre = pool_instance.admin_claimed_profit()
 
     pool_values_change = [pool_values_post[i] - pool_values_init[i] for i in [0, 1]]
     pool_value_surplus = sum(pool_values_change)
@@ -190,10 +193,20 @@ def test_claim_no_rebalancing(gm_pool, fee_receiver):
     # claim admin fees
     pool_instance.internal._claim_admin_fees()
     receiver_values_post = coin0_values(pool_instance, fee_receiver)
+    expected_fees = (
+        (xcp_profit_pre_claim - xcp_profit_a_pre_claim)
+        * pool_instance.lp_profit_fraction()
+        * pool_instance.admin_fee()
+        // 10**10
+        // 10**10
+    )
 
     value_received = sum(receiver_values_post) - sum(receiver_values_init)
     # approx because add_liq doesn't earn for xcp_profit
     assert value_received == pytest.approx(estimated_profit_admin, rel=1e-8)
+    assert pool_instance.xcp_profit() == xcp_profit_pre_claim
+    assert pool_instance.xcp_profit_a() == xcp_profit_pre_claim
+    assert pool_instance.admin_claimed_profit() == admin_claimed_profit_pre + expected_fees
 
 
 def test_n_claim_no_rebalancing(gm_pool, fee_receiver):
@@ -209,11 +222,14 @@ def test_n_claim_no_rebalancing(gm_pool, fee_receiver):
     assert pool_instance.coins[0].balanceOf(fee_receiver) == 0
     assert pool_instance.coins[1].balanceOf(fee_receiver) == 0
 
+    expected_admin_claimed_profit = 0
+
     for _ in range(N_REP):
         boa.env.time_travel(seconds=86_400)  # so that we can claim repeatedly
 
         pool_values_init = coin0_values(pool_instance, pool_instance.address)
         P_init = pool_instance.xcp_profit()
+        P_a_init = pool_instance.xcp_profit_a()
 
         work_pool(pool_instance, N_TRADES, TRADE_SIZE, update_ema=False)
         balance_pool(pool_instance)
@@ -242,10 +258,21 @@ def test_n_claim_no_rebalancing(gm_pool, fee_receiver):
         receiver_values_init = coin0_values(pool_instance, fee_receiver)
         pool_instance.internal._claim_admin_fees()
         receiver_values_post = coin0_values(pool_instance, fee_receiver)
+        expected_fees = (
+            (P_post - P_a_init)
+            * pool_instance.lp_profit_fraction()
+            * pool_instance.admin_fee()
+            // 10**10
+            // 10**10
+        )
+        expected_admin_claimed_profit += expected_fees
 
         value_received = sum(receiver_values_post) - sum(receiver_values_init)
 
         assert value_received == pytest.approx(estimated_profit_admin, rel=1e-2)
+        assert pool_instance.xcp_profit() == P_post
+        assert pool_instance.xcp_profit_a() == P_post
+        assert pool_instance.admin_claimed_profit() == expected_admin_claimed_profit
 
 
 def test_n_claim_lp_no_rebalancing(gm_pool, fee_receiver):

tests/unitary/pool/test_claim_admin_fees_grid.py

@@ -62,6 +62,7 @@ def test_claim_admin_fees_grid_no_rebalancing(
 
         xcp_profit_pre = pool_instance.xcp_profit()
         xcp_profit_a_pre = pool_instance.xcp_profit_a()
+        admin_claimed_profit_pre = pool_instance.admin_claimed_profit()
         virtual_price_pre = pool_instance.virtual_price()
         D_pre = pool_instance.D()
         balances_pre = pool_instance.balances()
@@ -73,7 +74,6 @@ def test_claim_admin_fees_grid_no_rebalancing(
 
         accrued = xcp_profit_pre - xcp_profit_a_pre
         expected_fees = accrued * lp_profit_fraction * admin_fee // FEE_PRECISION // FEE_PRECISION
-        expected_xcp_drop = expected_fees * FEE_PRECISION // lp_profit_fraction
         expected_vp_post = virtual_price_pre - expected_fees
         expected_D_post = D_pre - D_pre * expected_fees // virtual_price_pre
         expected_admin_amounts = [
@@ -92,8 +92,9 @@ def test_claim_admin_fees_grid_no_rebalancing(
         assert actual_admin_amounts == expected_admin_amounts
 
         assert pool_instance.virtual_price() == expected_vp_post
-        assert pool_instance.xcp_profit() == xcp_profit_pre - expected_xcp_drop
-        assert pool_instance.xcp_profit_a() == xcp_profit_pre - expected_xcp_drop
+        assert pool_instance.xcp_profit() == xcp_profit_pre
+        assert pool_instance.xcp_profit_a() == xcp_profit_pre
+        assert pool_instance.admin_claimed_profit() == admin_claimed_profit_pre + expected_fees
         assert pool_instance.D() == expected_D_post
 
         receiver_value_post = sum(coin0_values(pool_instance, fee_receiver))

tests/unitary/pool/test_rebalance_compounding.py

@@ -53,6 +53,7 @@ def _snapshot(pool_instance):
     return {
         "virtual_price": pool_instance.virtual_price(),
         "xcp_profit": pool_instance.xcp_profit(),
+        "admin_claimed_profit": pool_instance.admin_claimed_profit(),
         "get_virtual_price": pool_instance.get_virtual_price(),
         "price_scale": pool_instance.price_scale(),
         "price_oracle": pool_instance.price_oracle(),
@@ -113,6 +114,27 @@ def _run_rebalance_probe(pool_instance):
     return rebalance_count, price_scale_path
 
 
+def _inject_threshold_probe(pool_instance):
+    pool_instance.inject_function(
+        """
+@external
+@view
+def threshold_probe() -> uint256:
+    threshold_base: uint256 = (
+        10**18
+        + (max(self.xcp_profit, 10**18) - 10**18) * self.lp_profit_fraction // 10**10
+    )
+    threshold_vp: uint256 = threshold_base
+    if threshold_base > 10**18:
+        threshold_vp = unsafe_sub(
+            threshold_base,
+            min(self.admin_claimed_profit, unsafe_sub(threshold_base, 10**18)),
+        )
+    return threshold_vp
+"""
+    )
+
+
 def test_synthetic_vp_xcp_state_is_coherent(pool, factory_admin):
     with boa.env.anchor():
         boa.env.enable_fast_mode()
@@ -202,3 +224,20 @@ def test_same_block_noop_does_not_consume_rebalance_slot(pool, factory_admin):
         )
 
         assert pool_instance.price_scale() != price_scale_before
+
+
+def test_admin_claimed_profit_offsets_threshold_vp_with_floor(pool):
+    with boa.env.anchor():
+        pool_instance = GodModePool(pool)
+        pool_instance.add_liquidity_balanced(INITIAL_LIQ)
+        _inject_threshold_probe(pool_instance)
+
+        pool_instance.eval("self.xcp_profit = 3 * 10**18")
+        pool_instance.eval("self.admin_claimed_profit = 0")
+        assert pool_instance.instance.inject.threshold_probe() == 2 * PRECISION
+
+        pool_instance.eval("self.admin_claimed_profit = 3 * 10**17")
+        assert pool_instance.instance.inject.threshold_probe() == 17 * PRECISION // 10
+
+        pool_instance.eval("self.admin_claimed_profit = 5 * 10**18")
+        assert pool_instance.instance.inject.threshold_probe() == PRECISION

tests/unitary/twocrypto/test_policy_parity.py

@@ -21,6 +21,7 @@ def _state_snapshot(pool):
         "virtual_price": pool.virtual_price(),
         "xcp_profit": pool.xcp_profit(),
         "xcp_profit_a": pool.xcp_profit_a(),
+        "admin_claimed_profit": pool.admin_claimed_profit(),
     }
 
 

tests/utils/god_mode.py

@@ -133,6 +133,7 @@ def get_metrics_snapshot(self):
             "virtual_price": self.instance.virtual_price(),
             "xcp_profit": self.instance.xcp_profit(),
             "xcp_profit_a": self.instance.xcp_profit_a(),
+            "admin_claimed_profit": self.instance.admin_claimed_profit(),
             "price_scale": self.instance.price_scale(),
             "price_oracle": self.instance.price_oracle(),
             "total_supply": self.instance.totalSupply(),