Fix/Uniswap Liquidity Error #225 [WIP]

hummingbot/connector/gateway/amm_lp/gateway_evm_amm_lp.py

@@ -52,7 +52,7 @@ class GatewayEVMAMMLP(ConnectorBase):
     """
 
     API_CALL_TIMEOUT = 10.0
-    POLL_INTERVAL = 1.0
+    POLL_INTERVAL = 10.0
     UPDATE_BALANCE_INTERVAL = 30.0
     APPROVAL_ORDER_ID_PATTERN = re.compile(r"approve-(\w+)-(\w+)")
 
@@ -1256,3 +1256,9 @@ def tracking_states(self) -> Dict[str, any]:
     def _get_gateway_instance(self) -> GatewayHttpClient:
         gateway_instance = GatewayHttpClient.get_instance(self._client_config)
         return gateway_instance
+
+    def set_pool_interval(self, interval: int):
+        self.POLL_INTERVAL = interval
+
+    def set_update_balance_interval(self, interval: int):
+        self.UPDATE_BALANCE_INTERVAL = interval

hummingbot/strategy/amm_v3_lp/amm_v3_lp_config_map.py

@@ -1,6 +1,6 @@
 from decimal import Decimal
 
-from hummingbot.client.config.config_validators import validate_decimal, validate_market_trading_pair
+from hummingbot.client.config.config_validators import validate_decimal, validate_int, validate_market_trading_pair
 from hummingbot.client.config.config_var import ConfigVar
 from hummingbot.client.settings import (
     AllConnectorSettings,
@@ -71,17 +71,37 @@ def market_prompt() -> str:
         validator=lambda v: validate_decimal(v, Decimal("0"), inclusive=False),
         default=Decimal("1"),
         prompt_on_new=True),
-    "amount": ConfigVar(
-        key="amount",
+    "buffer_spread": ConfigVar(
+        key="buffer_spread",
+        prompt="How far from the position price range do you want to keep the position active? (Enter 1 to indicate 1%)  >>> ",
+        type_str="decimal",
+        validator=lambda v: validate_decimal(v, Decimal("0"), inclusive=False),
+        default=Decimal("0.5"),
+        prompt_on_new=True),
+    "max_amount": ConfigVar(
+        key="max_amount",
         prompt="Enter the maximum value(in terms of base asset) to use for providing liquidity. >>>",
         prompt_on_new=True,
         validator=lambda v: validate_decimal(v, Decimal("0"), inclusive=False),
         type_str="decimal"),
+    "min_amount": ConfigVar(
+        key="min_amount",
+        prompt="Enter the minimum value (in terms of base asset) to use for providing liquidity. >>>",
+        prompt_on_new=True,
+        validator=lambda v: validate_decimal(v, Decimal("0"), inclusive=False),
+        type_str="decimal"),
     "min_profitability": ConfigVar(
         key="min_profitability",
         prompt="What is the minimum unclaimed fees an out of range position must have before it is closed? (in terms of base asset) >>>",
         prompt_on_new=False,
         validator=lambda v: validate_decimal(v, Decimal("0"), inclusive=False),
         default=Decimal("1"),
         type_str="decimal"),
+    "status_report_interval": ConfigVar(
+        key="status_report_interval",
+        prompt="How often should the bot get market updates from gateway? (in seconds) >>>",
+        prompt_on_new=True,
+        validator=lambda v: validate_int(v, 1, inclusive=True),
+        default=10,
+        type_str="int"),
 }

hummingbot/strategy/amm_v3_lp/start.py

@@ -10,8 +10,11 @@ def start(self):
     pair = c_map.get("market").value
     fee_tier = c_map.get("fee_tier").value
     price_spread = c_map.get("price_spread").value / Decimal("100")
-    amount = c_map.get("amount").value
+    buffer_spread = c_map.get("buffer_spread").value / Decimal("100")
+    min_amount = c_map.get("min_amount").value
+    max_amount = c_map.get("max_amount").value
     min_profitability = c_map.get("min_profitability").value
+    status_report_interval = c_map.get("status_report_interval").value
 
     self._initialize_markets([(connector, [pair])])
     base, quote = pair.split("-")
@@ -21,5 +24,8 @@ def start(self):
     self.strategy = AmmV3LpStrategy(market_info,
                                     fee_tier,
                                     price_spread,
-                                    amount,
-                                    min_profitability)
+                                    buffer_spread,
+                                    min_amount,
+                                    max_amount,
+                                    min_profitability,
+                                    status_report_interval)

hummingbot/templates/conf_amm_v3_lp_strategy_TEMPLATE.yml

@@ -17,8 +17,15 @@ fee_tier: null
 # The spread between lower price to the upper price
 price_spread: null
 
+# The buffer to keep position active when price is moving out of range
+buffer_spread: null
+
 # The amount of token (liquidity) provided to the pool
-amount: null
+max_amount: null
+min_amount: null
 
 # The minimum profit required before positions can be adjusted
 min_profitability: null
+
+# How often should the bot get market updates from gateway?
+status_report_interval: null

test/hummingbot/strategy/amm_v3_lp/test_amm_v3_lp.py

@@ -137,13 +137,16 @@ async def check_network(self) -> NetworkStatus:
     async def cancel_outdated_orders(self, _: int) -> List:
         return []
 
+    async def _update_balances(self):
+        pass
+
 
 class AmmV3LpUnitTest(unittest.TestCase):
     def setUp(self):
         self.clock: Clock = Clock(ClockMode.REALTIME)
         self.stack: contextlib.ExitStack = contextlib.ExitStack()
         self.lp: MockAMMLP = MockAMMLP("onion")
-        self.lp.set_balance(BASE_ASSET, 500)
+        self.lp.set_balance(BASE_ASSET, 5)
         self.lp.set_balance(QUOTE_ASSET, 500)
         self.market_info = MarketTradingPairTuple(self.lp, TRADING_PAIR, BASE_ASSET, QUOTE_ASSET)
 
@@ -154,7 +157,8 @@ def setUp(self):
             self.market_info,
             "LOW",
             Decimal("0.2"),
-            Decimal("1"),
+            Decimal("10"),
+            Decimal("100"),
             Decimal("10"),
         )
         self.clock.add_iterator(self.lp)
@@ -193,19 +197,27 @@ async def test_format_status(self):
 
   Assets:
       Exchange Asset  Total Balance  Available Balance
-    0    onion  HBOT            500                500
+    0    onion  HBOT              5                  5
     1    onion  USDT            500                500"""
         current_status = await self.strategy.format_status()
         print(current_status)
         self.assertTrue(expected_status in current_status)
 
     @async_test(loop=ev_loop)
-    async def test_any_active_position(self):
+    async def test_any_active_position_when_below_min_amount(self):
+        await asyncio.sleep(2)
+        self.assertFalse(self.strategy.any_active_position(Decimal("1")))
+
+    @async_test(loop=ev_loop)
+    async def test_any_active_position_when_above_min_amount(self):
+        await asyncio.sleep(2)
+        self.lp.set_balance(BASE_ASSET, 500)
         await asyncio.sleep(2)
         self.assertTrue(self.strategy.any_active_position(Decimal("1")))
 
     @async_test(loop=ev_loop)
     async def test_positions_are_created_with_price(self):
+        self.lp.set_balance(BASE_ASSET, 500)
         await asyncio.sleep(2)
         self.assertEqual(len(self.strategy.active_positions), 1)
         self.lp.set_price(TRADING_PAIR, 2)

test/hummingbot/strategy/amm_v3_lp/test_amm_v3_lp_start.py

@@ -21,7 +21,8 @@ def setUp(self) -> None:
         amm_v3_lp_config_map.get("market").value = "ETH-USDT"
         amm_v3_lp_config_map.get("fee_tier").value = "LOW"
         amm_v3_lp_config_map.get("price_spread").value = Decimal("1")
-        amm_v3_lp_config_map.get("amount").value = Decimal("1")
+        amm_v3_lp_config_map.get("max_amount").value = Decimal("10")
+        amm_v3_lp_config_map.get("min_amount").value = Decimal("1")
         amm_v3_lp_config_map.get("min_profitability").value = Decimal("10")
 
     def _initialize_market_assets(self, market, trading_pairs):
@@ -42,5 +43,6 @@ def error(self, message, exc_info):
     @unittest.mock.patch('hummingbot.strategy.amm_v3_lp.amm_v3_lp.AmmV3LpStrategy.add_markets')
     def test_amm_v3_lp_strategy_creation(self, mock):
         amm_v3_lp_start.start(self)
-        self.assertEqual(self.strategy._amount, Decimal(1))
+        self.assertEqual(self.strategy._max_amount, Decimal(10))
+        self.assertEqual(self.strategy._min_amount, Decimal(1))
         self.assertEqual(self.strategy._min_profitability, Decimal("10"))