wayfinder-paths 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

wayfinder_paths/strategies/stablecoin_yield_strategy/strategy.py

@@ -179,6 +179,10 @@ class StablecoinYieldStrategy(Strategy):
         self.pool_adapter = None
         self.brap_adapter = None
 
+        # State tracking for deterministic token management
+        self.tracked_token_ids: set[str] = set()  # All tokens strategy might hold
+        self.tracked_balances: dict[str, int] = {}  # token_id -> balance in wei
+
         try:
             main_wallet_cfg = self.config.get("main_wallet")
             strategy_wallet_cfg = self.config.get("strategy_wallet")
@@ -251,6 +255,45 @@ class StablecoinYieldStrategy(Strategy):
             raise ValueError("main_wallet address not found in config")
         return str(address)
 
+    def _track_token(self, token_id: str, balance_wei: int = 0):
+        """Track a token that the strategy holds or might hold."""
+        if token_id:
+            self.tracked_token_ids.add(token_id)
+            if balance_wei > 0:
+                self.tracked_balances[token_id] = balance_wei
+
+    def _update_balance(self, token_id: str, balance_wei: int):
+        """Update the tracked balance for a token."""
+        if token_id:
+            self.tracked_balances[token_id] = balance_wei
+            if balance_wei > 0:
+                self.tracked_token_ids.add(token_id)
+
+    async def _refresh_tracked_balances(self):
+        """Refresh balances for all tracked tokens from on-chain data."""
+        strategy_address = self._get_strategy_wallet_address()
+        for token_id in self.tracked_token_ids:
+            try:
+                success, balance_wei = await self.balance_adapter.get_balance(
+                    token_id=token_id,
+                    wallet_address=strategy_address,
+                )
+                if success and balance_wei:
+                    self.tracked_balances[token_id] = int(balance_wei)
+                else:
+                    self.tracked_balances[token_id] = 0
+            except Exception as e:
+                logger.warning(f"Failed to refresh balance for {token_id}: {e}")
+                self.tracked_balances[token_id] = 0
+
+    def _get_non_zero_tracked_tokens(self) -> list[tuple[str, int]]:
+        """Get list of (token_id, balance_wei) for tokens with non-zero balances."""
+        return [
+            (token_id, balance)
+            for token_id, balance in self.tracked_balances.items()
+            if balance > 0
+        ]
+
     async def setup(self):
         logger.info("Starting StablecoinYieldStrategy setup")
         start_time = time.time()
@@ -292,6 +335,10 @@ class StablecoinYieldStrategy(Strategy):
             logger.error(f"Error fetching USDC token info: {e}")
             self.usdc_token_info = {}
 
+        # Always track USDC as baseline token
+        if self.usdc_token_info.get("token_id"):
+            self._track_token(self.usdc_token_info.get("token_id"))
+
         self.current_pool = {
             "token_id": self.usdc_token_info.get("token_id"),
             "name": self.usdc_token_info.get("name"),
@@ -316,6 +363,9 @@ class StablecoinYieldStrategy(Strategy):
                 logger.info(
                     f"Gas token loaded: {gas_token_data.get('symbol', 'Unknown')}"
                 )
+                # Track gas token (but don't count it as a strategy asset)
+                if self.gas_token.get("id"):
+                    self._track_token(self.gas_token.get("id"))
             else:
                 logger.warning("Failed to fetch gas token info, using empty dict")
                 self.gas_token = {}
@@ -328,9 +378,9 @@ class StablecoinYieldStrategy(Strategy):
             self.current_pool_balance = 0
             return
 
-        # Get strategy transactions to determine current position
+        # Get strategy transactions to determine current position and build tracked token set
         try:
-            logger.info("Fetching strategy transaction history")
+            logger.info("Fetching strategy transaction history to build state")
             success, txns_data = await self.ledger_adapter.get_strategy_transactions(
                 wallet_address=self._get_strategy_wallet_address(),
             )
@@ -341,6 +391,20 @@ class StablecoinYieldStrategy(Strategy):
                     if txn.get("operation") != "DEPOSIT"
                 ]
                 logger.info(f"Found {len(txns)} non-deposit transactions")
+
+                # Build tracked token set from transaction history
+                for txn in txns:
+                    op_data = txn.get("data", {}).get("op_data", {})
+                    # Track any token that was swapped TO
+                    if op_data.get("to_token_id"):
+                        self._track_token(op_data.get("to_token_id"))
+                    # Track any token that was swapped FROM
+                    if op_data.get("from_token_id"):
+                        self._track_token(op_data.get("from_token_id"))
+
+                logger.info(
+                    f"Tracking {len(self.tracked_token_ids)} tokens from history"
+                )
             else:
                 logger.error(f"Failed to fetch strategy transactions: {txns_data}")
                 txns = []
@@ -363,6 +427,9 @@ class StablecoinYieldStrategy(Strategy):
                 "address": token_info.get("address"),
                 "chain": token_info.get("chain"),
             }
+            # Track the current pool token
+            if token_info.get("token_id"):
+                self._track_token(token_info.get("token_id"))
 
             success, reports = await self.pool_adapter.get_pools_by_ids(
                 pool_ids=[self.current_pool.get("token_id")],
@@ -442,6 +509,12 @@ class StablecoinYieldStrategy(Strategy):
             == self.current_pool.get("chain").get("id")
             else None
         )
+        # Refresh all tracked balances from blockchain
+        await self._refresh_tracked_balances()
+        logger.info(
+            f"Refreshed balances for {len(self.tracked_balances)} tracked tokens"
+        )
+
         if (
             baseline_token
             and self.current_pool.get("token_id") != baseline_token.get("token_id")
@@ -449,7 +522,8 @@ class StablecoinYieldStrategy(Strategy):
         ):
             return
 
-        inferred = await self._infer_active_pool_from_wallet()
+        # Fallback: Try to infer active pool from tracked tokens with balances
+        inferred = await self._infer_active_pool_from_tracked_tokens()
         if inferred is not None:
             inferred_token, inferred_balance, inferred_entry = inferred
             self.current_pool = inferred_token
@@ -502,95 +576,60 @@ class StablecoinYieldStrategy(Strategy):
                 continue
         return total_usd
 
-    async def _infer_active_pool_from_wallet(self):
+    async def _infer_active_pool_from_tracked_tokens(self):
+        """Infer the active pool from tracked tokens with non-zero balances."""
         try:
-            (
-                _,
-                wallet_balances,
-            ) = await self.balance_adapter.get_all_balances(
-                wallet_address=self._get_strategy_wallet_address(),
-                enrich=True,
-                from_cache=False,
-                add_llama=True,
-            )
-        except Exception:
-            return None
+            # Refresh balances for tracked tokens
+            await self._refresh_tracked_balances()
 
-        if not wallet_balances:
-            return None
+            usdc_token_id = self.usdc_token_info.get("token_id")
+            gas_token_id = self.gas_token.get("id") if self.gas_token else None
 
-        target_chain = self.current_pool.get("chain").get("name").lower()
-        usdc_token = (
-            self.usdc_token_info
-            if self.usdc_token_info.get("chain").get("name").lower() == target_chain
-            else None
-        )
-        usdc_address = usdc_token.get("address").lower() if usdc_token else ""
+            best_token_id = None
+            best_balance_wei = 0
 
-        best_entry = None
-        best_balance_wei = 0
-        best_balance_usd = 0.0
+            # Find the non-gas, non-USDC token with the largest balance
+            for token_id, balance_wei in self.tracked_balances.items():
+                if balance_wei <= 0:
+                    continue
+                if token_id == gas_token_id:
+                    continue
+                if token_id == usdc_token_id:
+                    continue
 
-        for balance in wallet_balances.get("balances"):
-            if self._is_gas_balance_entry(balance):
-                continue
+                # Prefer tokens with larger balances
+                if balance_wei > best_balance_wei:
+                    best_token_id = token_id
+                    best_balance_wei = balance_wei
 
-            network = (balance.get("network") or "").lower()
-            if network != target_chain:
-                continue
+            if not best_token_id:
+                return None
 
-            token_address = balance.get("tokenAddress")
-            if not token_address or token_address.lower() == usdc_address:
-                continue
+            # Fetch token info
+            success, token = await self.token_adapter.get_token(best_token_id)
+            if not success:
+                return None
 
-            raw_balance = balance.get("balance_base_units")
+            # Get fresh on-chain balance
+            strategy_address = self._get_strategy_wallet_address()
             try:
-                balance_wei = int(raw_balance)
-            except (TypeError, ValueError):
-                continue
-            if balance_wei <= 0:
-                continue
-
-            balance_usd = float(balance.get("balanceUSD") or 0.0)
-            if balance_usd <= 0:
-                continue
-
-            if best_entry is None or balance_usd > best_balance_usd:
-                best_entry = balance
-                best_balance_wei = balance_wei
-                best_balance_usd = balance_usd
-
-        # TODO: no successful best entry found in manual testing
-        if not best_entry:
-            return None
-
-        token_id = best_entry.get("token_id")
-        token_address = best_entry.get("tokenAddress")
-        if not token_id and token_address:
-            token_id = f"{target_chain}_{token_address.lower()}"
-
-        if not token_id:
-            return None
-
-        success, token = await self.token_adapter.get_token(token_id)
-        if not success:
-            return None
+                success, onchain_balance = await self.balance_adapter.get_balance(
+                    token_id=token.get("token_id"),
+                    wallet_address=strategy_address,
+                )
+                if success and onchain_balance:
+                    best_balance_wei = int(onchain_balance)
+            except Exception:
+                pass
 
-        try:
-            strategy_address = self._get_strategy_wallet_address()
-            (
-                success,
-                onchain_balance,
-            ) = await self.balance_adapter.get_balance(
-                token_id=token.get("token_id"),
-                wallet_address=strategy_address,
+            logger.info(
+                f"Inferred active pool: {token.get('symbol')} with balance {best_balance_wei}"
             )
-            if not success:
-                onchain_balance = best_balance_wei
-        except Exception:
-            onchain_balance = best_balance_wei
+            return token, best_balance_wei, None
 
-        return token, onchain_balance, dict(best_entry)
+        except Exception as e:
+            logger.error(f"Failed to infer active pool from tracked tokens: {e}")
+            return None
 
     def _is_gas_balance_entry(self, balance: dict[str, Any]) -> bool:
         """Check if a balance entry represents a gas token."""
@@ -791,6 +830,13 @@ class StablecoinYieldStrategy(Strategy):
                     return (False, f"USDC transfer to strategy failed: {msg}")
                 logger.info("USDC transfer completed successfully")
 
+                # Update tracked state
+                self._track_token(self.usdc_token_info.get("token_id"))
+                self._update_balance(
+                    self.usdc_token_info.get("token_id"),
+                    int(main_token_amount * (10 ** self.current_pool.get("decimals"))),
+                )
+
             # Transfer gas if provided or if strategy needs top-up
             if gas_token_amount > 0:
                 # Get gas symbol if not already defined
@@ -1149,6 +1195,10 @@ class StablecoinYieldStrategy(Strategy):
             strategy_name=self.name,
         )
 
+        # Track the new target pool token
+        if target_pool and target_pool.get("token_id"):
+            self._track_token(target_pool.get("token_id"))
+
         self.current_pool = target_pool
         if self.current_pool and self.current_pool.get("token_id"):
             success, pool_reports = await self.pool_adapter.get_pools_by_ids(
@@ -1206,49 +1256,81 @@ class StablecoinYieldStrategy(Strategy):
         except Exception:
             pass
 
-    # TODO untested
     async def _sweep_wallet(self, target_token):
-        (
-            _,
-            wallet_balances,
-        ) = await self.balance_adapter.get_all_balances(
-            wallet_address=self._get_strategy_wallet_address(),
-            enrich=True,
-            from_cache=False,
-            add_llama=True,
-        )
-        target_chain = target_token.get("chain").get("name").lower()
-        target_address = target_token.get("address").lower()
-
-        for balance in wallet_balances.get("balances"):
-            if self._is_gas_balance_entry(balance):
+        """Sweep all tracked non-target tokens into the target token."""
+        # Refresh tracked balances
+        await self._refresh_tracked_balances()
+
+        target_token_id = target_token.get("token_id")
+        target_chain = target_token.get("chain").get("code", "").lower()
+        target_address = target_token.get("address", "").lower()
+        gas_token_id = self.gas_token.get("id") if self.gas_token else None
+
+        # Swap all non-target, non-gas tokens to the target
+        for token_id, balance_wei in list(self.tracked_balances.items()):
+            # Skip if no balance
+            if balance_wei <= 0:
                 continue
 
-            balance_raw = balance.get("balance_base_units")
-            token_address = balance.get("tokenAddress")
-            network = balance.get("network", "").lower()
-
-            if not balance_raw or not token_address:
+            # Skip gas token
+            if token_id == gas_token_id:
                 continue
-            if network == target_chain and token_address.lower() == target_address:
+
+            # Skip if it's already the target token
+            if token_id == target_token_id:
                 continue
 
+            # Get fresh balance to ensure accuracy
             try:
-                token_1_id = f"{network}_{token_address.lower()}"
-                target_token_id = f"{target_chain}_{target_address.lower()}"
+                success, fresh_balance = await self.balance_adapter.get_balance(
+                    token_id=token_id,
+                    wallet_address=self._get_strategy_wallet_address(),
+                )
+                if not success or not fresh_balance or int(fresh_balance) <= 0:
+                    self._update_balance(token_id, 0)
+                    continue
+
+                balance_wei = int(fresh_balance)
+            except Exception:
+                continue
 
+            # Construct target token ID for swap
+            target_token_id_for_swap = f"{target_chain}_{target_address}"
+
+            try:
+                logger.info(
+                    f"Sweeping {token_id} (balance: {balance_wei}) to {target_token_id}"
+                )
                 success, msg = await self.brap_adapter.swap_from_token_ids(
-                    token_1_id,
-                    target_token_id,
+                    token_id,
+                    target_token_id_for_swap,
                     self._get_strategy_wallet_address(),
-                    balance_raw,
+                    str(balance_wei),
                     strategy_name=self.name,
                 )
-                if not success:
-                    return (False, f"Swap failed: {msg}")
-            except Exception:
+                if success:
+                    # Update tracked state: source token now has 0 balance
+                    self._update_balance(token_id, 0)
+                    logger.info(f"Successfully swept {token_id} to {target_token_id}")
+                else:
+                    logger.warning(f"Failed to sweep {token_id}: {msg}")
+            except Exception as e:
+                logger.error(f"Error sweeping {token_id}: {e}")
                 continue
 
+        # Track the target token
+        self._track_token(target_token_id)
+        # Refresh target token balance
+        try:
+            success, target_balance = await self.balance_adapter.get_balance(
+                token_id=target_token_id,
+                wallet_address=self._get_strategy_wallet_address(),
+            )
+            if success and target_balance:
+                self._update_balance(target_token_id, int(target_balance))
+        except Exception:
+            pass
+
     async def _rebalance_gas(self, target_pool) -> tuple[bool, str]:
         if self.gas_token.get("chain").get("id") != target_pool.get("chain").get("id"):
             return False, "Unsupported chain for gas management."
@@ -1326,82 +1408,40 @@ class StablecoinYieldStrategy(Strategy):
         )
 
     async def _get_non_gas_balances(self) -> list[dict[str, Any]]:
-        results = []
+        """Get non-gas balances from tracked tokens."""
+        # Refresh tracked balances
+        await self._refresh_tracked_balances()
 
-        if self.current_pool != self.usdc_token_info:
-            (
-                status,
-                balance_wei,
-            ) = await self.balance_adapter.get_balance(
-                token_id=self.usdc_token_info.get("token_id"),
-                wallet_address=self._get_strategy_wallet_address(),
-            )
-            if not status or not balance_wei:
-                pass
-            results.append(
-                {
-                    "token_id": self.usdc_token_info.get("token_id"),
-                    "tokenAddress": self.usdc_token_info.get("address"),
-                    "network": self.usdc_token_info.get("chain").get("code").upper(),
-                    "_amount_wei": balance_wei,
-                }
-            )
-        else:
-            results.append(
-                {
-                    "token_id": self.usdc_token_info.get("token_id"),
-                    "tokenAddress": self.usdc_token_info.get("address"),
-                    "network": self.usdc_token_info.get("chain").get("code").upper(),
-                    "_amount_wei": self.current_pool_balance
-                    * (10 ** self.usdc_token_info.get("decimals")),
-                }
-            )
+        gas_token_id = self.gas_token.get("id") if self.gas_token else None
+        results = []
 
-        try:
-            (
-                _,
-                wallet_balances,
-            ) = await self.balance_adapter.get_all_balances(
-                wallet_address=self._get_strategy_wallet_address(),
-                enrich=True,
-                from_cache=False,
-                add_llama=True,
-            )
-        except Exception:
-            wallet_balances = []
+        for token_id, balance_wei in self.tracked_balances.items():
+            # Skip gas token
+            if token_id == gas_token_id:
+                continue
 
-        for balance in wallet_balances.get("balances"):
-            if self._is_gas_balance_entry(balance):
+            # Skip zero balances
+            if balance_wei <= 0:
                 continue
 
-            raw = balance.get("balance_base_units")
+            # Fetch token info to get address and chain
             try:
-                amount_wei = int(raw)
-            except (TypeError, ValueError):
-                continue
-            if amount_wei <= 0:
-                continue
+                success, token_info = await self.token_adapter.get_token(token_id)
+                if not success or not token_info:
+                    continue
 
-            token_address = balance.get("tokenAddress")
-            network = (balance.get("network") or "").lower()
-            if not token_address or not network:
+                results.append(
+                    {
+                        "token_id": token_id,
+                        "tokenAddress": token_info.get("address"),
+                        "network": token_info.get("chain", {}).get("code", "").upper(),
+                        "_amount_wei": balance_wei,
+                    }
+                )
+            except Exception as e:
+                logger.warning(f"Failed to get token info for {token_id}: {e}")
                 continue
 
-            candidate = {
-                "token_id": balance.get("token_id")
-                or f"{network}_{token_address.lower()}",
-                "tokenAddress": token_address,
-                "network": network.upper(),
-                "_amount_wei": amount_wei,
-            }
-
-            exists = any(
-                entry.get("token_id").lower() == candidate.get("token_id").lower()
-                for entry in results
-            )
-            if not exists:
-                results.append(candidate)
-
         return results
 
     async def _find_best_pool(self) -> tuple[bool, dict[str, Any]]:
@@ -1545,37 +1585,63 @@ class StablecoinYieldStrategy(Strategy):
         return float(gas_price) * float(amount) / (10 ** token.get("decimals"))
 
     async def _status(self) -> StatusDict:
+        # Get ETH gas balance
+        gas_success, gas_balance_wei = await self.balance_adapter.get_balance(
+            token_id=self.gas_token.get("id"),
+            wallet_address=self._get_strategy_wallet_address(),
+        )
+        gas_balance = (
+            float(gas_balance_wei) / (10 ** self.gas_token.get("decimals"))
+            if gas_success
+            else 0.0
+        )
+
         if not self.DEPOSIT_USDC:
-            (
-                _,
-                wallet_balances,
-            ) = await self.balance_adapter.get_all_balances(
-                wallet_address=self._get_main_wallet_address(),
-                enrich=True,
-                from_cache=False,
-                add_llama=True,
-            )
-            total_value = self._sum_non_gas_balance_usd(wallet_balances.get("balances"))
+            # No deposits recorded - report minimal status
             status_payload = {
-                "info": "No recorded strategy deposits; reporting current wallet holdings only.",
-                "idle_usd": total_value,
+                "info": "No recorded strategy deposits.",
+                "idle_usd": 0.0,
             }
 
             return StatusDict(
-                portfolio_value=total_value,
+                portfolio_value=0.0,
                 net_deposit=0,
                 strategy_status=status_payload,
+                gas_available=gas_balance,
+                gassed_up=gas_balance >= self.GAS_MAXIMUM * self.GAS_SAFETY_FRACTION,
             )
-        (
-            _,
-            wallet_balances,
-        ) = await self.balance_adapter.get_all_balances(
-            wallet_address=self._get_strategy_wallet_address(),
-            enrich=True,
-            from_cache=False,
-            add_llama=True,
-        )
-        total_value = self._sum_non_gas_balance_usd(wallet_balances.get("balances"))
+
+        # Refresh tracked balances
+        await self._refresh_tracked_balances()
+
+        # Calculate total value from tracked non-gas balances
+        total_value = 0.0
+        gas_token_id = self.gas_token.get("id") if self.gas_token else None
+
+        for token_id, balance_wei in self.tracked_balances.items():
+            if token_id == gas_token_id:
+                continue
+            if balance_wei <= 0:
+                continue
+
+            try:
+                # Get token price to calculate USD value
+                success, price_data = await self.token_adapter.get_token_price(token_id)
+                if not success:
+                    continue
+
+                success, token_info = await self.token_adapter.get_token(token_id)
+                if not success:
+                    continue
+
+                decimals = token_info.get("decimals", 18)
+                price = price_data.get("current_price", 0.0)
+                balance_usd = (float(balance_wei) / (10**decimals)) * price
+                total_value += balance_usd
+            except Exception as e:
+                logger.warning(f"Failed to calculate value for {token_id}: {e}")
+                continue
+
         status_payload = (
             {
                 "current_pool": self.current_pool.get("token_id"),
@@ -1597,6 +1663,8 @@ class StablecoinYieldStrategy(Strategy):
             portfolio_value=total_value,
             net_deposit=self.DEPOSIT_USDC,
             strategy_status=status_payload,
+            gas_available=gas_balance,
+            gassed_up=gas_balance >= self.GAS_MAXIMUM * self.GAS_SAFETY_FRACTION,
         )
 
     @staticmethod
@@ -1611,111 +1679,132 @@ class StablecoinYieldStrategy(Strategy):
         return [f"({wallet_id}) && (({approve_enso}) || ({swap_enso})) "]
 
     async def partial_liquidate(self, usd_value: float) -> StatusTuple:
-        (
-            _,
-            wallet_balances,
-        ) = await self.balance_adapter.get_all_balances(
-            wallet_address=self._get_strategy_wallet_address(),
-            enrich=True,
-            from_cache=False,
-            add_llama=True,
-        )
-        _, total_usdc_wei = await self.balance_adapter.get_balance(
-            token_id=self.usdc_token_info.get("token_id"),
-            wallet_address=self._get_strategy_wallet_address(),
-        )
-        available_usdc_usd = float(total_usdc_wei or 0) / (
-            10 ** self.usdc_token_info.get("decimals")
-        )
+        """Liquidate strategy assets to reach target USD value in USDC."""
+        # Refresh tracked balances
+        await self._refresh_tracked_balances()
+
+        usdc_token_id = self.usdc_token_info.get("token_id")
+        usdc_decimals = self.usdc_token_info.get("decimals")
+        gas_token_id = self.gas_token.get("id") if self.gas_token else None
 
-        for balance in wallet_balances.get("balances"):
+        # Check current USDC balance
+        available_usdc_wei = self.tracked_balances.get(usdc_token_id, 0)
+        available_usdc_usd = float(available_usdc_wei) / (10**usdc_decimals)
+
+        # Liquidate non-USDC, non-gas, non-current-pool tokens first
+        for token_id, balance_wei in list(self.tracked_balances.items()):
             if available_usdc_usd >= usd_value:
                 break
 
-            token_id = balance.get("token_id")
-            if token_id == self.usdc_token_info.get("token_id"):
+            # Skip USDC, gas, and current pool
+            if token_id == usdc_token_id:
                 continue
-            if token_id == self.gas_token.get("id"):
+            if token_id == gas_token_id:
                 continue
             if self.current_pool and token_id == self.current_pool.get("token_id"):
                 continue
 
-            (
-                balance_status,
-                balance_wei,
-            ) = await self.balance_adapter.get_balance(
-                token_id=token_id,
-                wallet_address=self._get_strategy_wallet_address(),
-            )
-            if not balance_status or not balance_wei:
+            # Skip zero balances
+            if balance_wei <= 0:
                 continue
-            price = float(balance.get("price", 0.0))
-            decimals = int(balance.get("decimals", 18))
-            token_usd_value = price * float(balance_wei) / (10**decimals)
-
-            if token_usd_value > 1.0:
-                needed_usd = usd_value - available_usdc_usd
-                required_token_wei = int(
-                    math.ceil((needed_usd * (10**decimals)) / price)
-                )
-                amount_to_swap = min(required_token_wei, balance_wei)
-                token_address = balance.get("tokenAddress")
-                network = balance.get("network", "").lower()
-                token_1_id = f"{network}_{token_address.lower()}"
-                try:
-                    await self.brap_adapter.swap_from_token_ids(
-                        token_1_id,
-                        f"{self.usdc_token_info.get('chain').get('name')}_{self.usdc_token_info.get('address').lower()}",
+
+            # Get token info and price
+            try:
+                success, token_info = await self.token_adapter.get_token(token_id)
+                if not success:
+                    continue
+
+                success, price_data = await self.token_adapter.get_token_price(token_id)
+                if not success:
+                    continue
+
+                decimals = token_info.get("decimals", 18)
+                price = price_data.get("current_price", 0.0)
+                token_usd_value = price * float(balance_wei) / (10**decimals)
+
+                if token_usd_value > 1.0:
+                    needed_usd = usd_value - available_usdc_usd
+                    required_token_wei = int(
+                        math.ceil((needed_usd * (10**decimals)) / price)
+                    )
+                    amount_to_swap = min(required_token_wei, balance_wei)
+
+                    logger.info(f"Liquidating {token_id} to USDC: {amount_to_swap} wei")
+                    success, msg = await self.brap_adapter.swap_from_token_ids(
+                        token_id,
+                        f"{self.usdc_token_info.get('chain').get('code')}_{self.usdc_token_info.get('address').lower()}",
                         self._get_strategy_wallet_address(),
-                        amount_to_swap,
+                        str(amount_to_swap),
                         strategy_name=self.name,
                     )
-                    swapped_usd = (amount_to_swap / (10**decimals)) * price
-                    available_usdc_usd += swapped_usd
-                except Exception as e:
-                    logger.error(f"Error swapping {token_address} to USDC: {e}")
+                    if success:
+                        swapped_usd = (amount_to_swap / (10**decimals)) * price
+                        available_usdc_usd += swapped_usd
+                        # Update tracked state
+                        self._update_balance(token_id, balance_wei - amount_to_swap)
+                    else:
+                        logger.warning(f"Failed to liquidate {token_id}: {msg}")
+            except Exception as e:
+                logger.error(f"Error liquidating {token_id}: {e}")
+                continue
 
-        _, total_usdc_wei = await self.balance_adapter.get_balance(
-            token_id=self.usdc_token_info.get("token_id"),
+        # Refresh USDC balance after swaps
+        success, usdc_wei = await self.balance_adapter.get_balance(
+            token_id=usdc_token_id,
             wallet_address=self._get_strategy_wallet_address(),
         )
-        usdc_decimals = self.usdc_token_info.get("decimals")
-        available_usdc_usd = float(total_usdc_wei or 0) / (10**usdc_decimals)
+        if success and usdc_wei:
+            available_usdc_wei = int(usdc_wei)
+            available_usdc_usd = float(available_usdc_wei) / (10**usdc_decimals)
+            self._update_balance(usdc_token_id, available_usdc_wei)
 
+        # If still not enough, liquidate from current pool
         if (
             available_usdc_usd < usd_value
             and self.current_pool
-            and self.current_pool.get("token_id")
-            != self.usdc_token_info.get("token_id")
+            and self.current_pool.get("token_id") != usdc_token_id
         ):
             remaining_usd = usd_value - available_usdc_usd
-            (
-                _,
-                pool_balance_wei,
-            ) = await self.balance_adapter.get_pool_balance(
-                pool_address=self.current_pool.get("address"),
-                chain_id=self.current_pool.get("chain").get("id"),
-                user_address=self._get_strategy_wallet_address(),
+            pool_balance_wei = self.tracked_balances.get(
+                self.current_pool.get("token_id"), 0
             )
             pool_decimals = self.current_pool.get("decimals")
             amount_to_swap = min(
-                int(pool_balance_wei or 0), int(remaining_usd * (10**pool_decimals))
+                pool_balance_wei, int(remaining_usd * (10**pool_decimals))
             )
 
-            try:
-                await self.brap_adapter.swap_from_token_ids(
-                    f"{self.current_pool.get('chain').get('code').lower()}_{self.current_pool.get('address').lower()}",
-                    f"{self.usdc_token_info.get('chain').get('name')}_{self.usdc_token_info.get('address').lower()}",
-                    self._get_strategy_wallet_address(),
-                    amount_to_swap,
-                    strategy_name=self.name,
+            if amount_to_swap > 0:
+                try:
+                    logger.info(
+                        f"Liquidating from current pool {self.current_pool.get('token_id')}"
+                    )
+                    success, msg = await self.brap_adapter.swap_from_token_ids(
+                        self.current_pool.get("token_id"),
+                        f"{self.usdc_token_info.get('chain').get('code')}_{self.usdc_token_info.get('address').lower()}",
+                        self._get_strategy_wallet_address(),
+                        str(amount_to_swap),
+                        strategy_name=self.name,
+                    )
+                    if success:
+                        self._update_balance(
+                            self.current_pool.get("token_id"),
+                            pool_balance_wei - amount_to_swap,
+                        )
+                except Exception as e:
+                    logger.error(f"Error swapping pool to USDC: {e}")
+
+                # Refresh USDC balance again
+                success, usdc_wei = await self.balance_adapter.get_balance(
+                    token_id=usdc_token_id,
+                    wallet_address=self._get_strategy_wallet_address(),
                 )
-            except Exception as e:
-                logger.error(f"Error swapping pool to USDC: {e}")
+                if success and usdc_wei:
+                    available_usdc_wei = int(usdc_wei)
+                    self._update_balance(usdc_token_id, available_usdc_wei)
 
-            _, total_usdc_wei = await self.balance_adapter.get_balance(
-                token_id=self.usdc_token_info.get("token_id"),
-                wallet_address=self._get_strategy_wallet_address(),
-            )
-        to_pay = min(int(total_usdc_wei or 0), int(usd_value * (10**usdc_decimals)))
-        return (True, f"Partial liquidation completed. Paid {to_pay} USDC")
+        to_pay = min(available_usdc_wei, int(usd_value * (10**usdc_decimals)))
+        to_pay_usd = float(to_pay) / (10**usdc_decimals)
+        return (
+            True,
+            f"Partial liquidation completed. Available: {to_pay_usd:.2f} USDC",
+        )