feat(debank): Move token list to Pool

blockapi/test/v2/api/debank/test_debank_portfolio_parser.py

@@ -39,7 +39,6 @@ def test_parse_supply_token_list(portfolio_parser, portfolio_response):
     items = portfolio_parser.parse([portfolio_response])[0].items
     filtered = [item for item in items if item.asset_type == AssetType.LENDING]
     for b in filtered:
-        assert b.token_role == TokenRole.SUPPLY
         assert b.pool_id == '0xdc13687554205e5b89ac783db14bb5bba4a1edac'
 
     assert len(filtered) == 1
@@ -56,7 +55,6 @@ def test_parse_borrow_token_list(portfolio_parser, portfolio_response):
     assert len(filtered) == 3
 
     for b in filtered:
-        assert b.token_role == TokenRole.BORROW
         assert b.pool_id == '0xdc13687554205e5b89ac783db14bb5bba4a1edac'
 
 
@@ -113,14 +111,8 @@ def test_parse_mutliple_items(portfolio_parser, aave_portfolio_response):
 
 def test_parse_esgmx_items(portfolio_parser, esgmx_portfolio_response):
     parsed = portfolio_parser.parse(esgmx_portfolio_response)
-    balances = []
-    for item in parsed:
-        balances.extend(item.items)
-
-    filtered = [b for b in balances if b.coin.symbol == 'esGMX']
-    assert len(filtered) == 4
-
-    assert parsed[2].items[1].token_set == ['GMX']
+    assert parsed[0].tokens == ['esGMX']
+    assert parsed[1].tokens == ['esGMX']
 
 
 def test_parse_tokenset(portfolio_parser, tokenset_portfolio_response):
@@ -133,6 +125,12 @@ def test_parse_tokenset(portfolio_parser, tokenset_portfolio_response):
     assert parsed[1].adapter_id == 'tokensets_investment2'
 
 
+def test_parse_pool_names(portfolio_parser, tokenset_portfolio_response):
+    parsed = portfolio_parser.parse(tokenset_portfolio_response)
+    assert parsed[0].tokens == ['USDC', 'WBTC']
+    assert parsed[1].tokens == ['ETH', 'USDC']
+
+
 def test_require_pool_or_pool_id():
     with pytest.raises(ValueError, match="either pool or pool_id must have a value"):
         detail = DebankModelPoolItemDetail()

blockapi/v2/api/debank.py

@@ -1,7 +1,7 @@
 import logging
 from datetime import datetime, timedelta
 from decimal import Decimal
-from typing import Dict, List, Optional, Union
+from typing import Dict, Iterable, List, Optional, Union
 
 import attr
 from eth_utils import to_checksum_address
@@ -244,18 +244,14 @@ def parse(
         response: List,
         asset_type: AssetType = AssetType.AVAILABLE,
         is_wallet: bool = True,
-        token_set: Optional[List[str]] = None,
-        token_role: Optional[TokenRole] = None,
         pool_id: Optional[str] = None,
     ) -> List[BalanceItem]:
         items = []
         for item in response:
             balance_item = DebankModelBalanceItem(**item)
             balance_item.raw_value = item
 
-            balance = self.parse_item(
-                balance_item, asset_type, is_wallet, token_set, token_role, pool_id
-            )
+            balance = self.parse_item(balance_item, asset_type, is_wallet, pool_id)
             if balance is not None:
                 items.append(balance)
 
@@ -266,8 +262,6 @@ def parse_item(
         balance_item: DebankModelBalanceItem,
         asset_type: AssetType = AssetType.AVAILABLE,
         is_wallet: bool = True,
-        token_set: Optional[List[str]] = None,
-        token_role: Optional[TokenRole] = None,
         pool_id: Optional[str] = None,
     ) -> Optional[BalanceItem]:
         raw_amount = balance_item.raw_amount or 0
@@ -311,8 +305,6 @@ def parse_item(
             raw=balance_item.raw_value,
             protocol=self._protocols.get(balance_item.protocol_id),
             is_wallet=is_wallet,
-            token_set=token_set,
-            token_role=token_role,
             pool_id=pool_id,
         )
 
@@ -429,92 +421,84 @@ def _parse_portfolio_item(
         locked_until = detail.unlock_at
         position_index = item.position_index
 
+        items = list(self._parse_balances(detail, item, pool_id))
+        pool = pools.get((pool_id, position_index))
+
+        if pool is None:
+            tokens = (
+                self._get_tokens(detail.supply_token_list)
+                if detail.supply_token_list
+                else []
+            )
+
+            pool = Pool.from_api(
+                pool_id=pool_id,
+                protocol=pool_protocol,
+                name=detail.description,
+                locked_until=locked_until,
+                health_rate=health_rate,
+                items=items,
+                project_id=item.pool.project_id if item.pool else None,
+                adapter_id=item.pool.adapter_id if item.pool else None,
+                position_index=position_index,
+                tokens=tokens,
+            )
+        else:
+            pool.append_items(items)
+
+        return pool
+
+    def _parse_balances(self, detail, item, pool_id) -> Iterable[BalanceItem]:
         asset_type = self._parse_asset_type(item.name)
         borrow_type = self._get_borrow_asset_type(asset_type)
         reward_type = self._get_reward_asset_type(asset_type)
 
-        items = []
-
-        tokens = self._update_items(
-            items,
+        yield from self._parse_token_list(
             detail.supply_token_list,
             asset_type,
-            token_role=TokenRole.SUPPLY,
             pool_id=pool_id,
         )
-        self._update_items(
-            items,
+
+        yield from self._parse_token_list(
             detail.borrow_token_list,
             borrow_type,
-            tokens,
-            token_role=TokenRole.BORROW,
             pool_id=pool_id,
         )
-        self._update_items(
-            items,
+
+        yield from self._parse_token_list(
             detail.reward_token_list,
             reward_type,
-            tokens,
-            token_role=TokenRole.REWARD,
             pool_id=pool_id,
         )
-        self._update_items(items, detail.token_list, asset_type, pool_id=pool_id)
 
-        pool = pools.get((pool_id, position_index))
+        yield from self._parse_token_list(
+            detail.token_list, asset_type, pool_id=pool_id
+        )
 
-        if pool is None:
-            pool = Pool.from_api(
-                pool_id=pool_id,
-                protocol=pool_protocol,
-                name=detail.description,
-                locked_until=locked_until,
-                health_rate=health_rate,
-                items=items,
-                project_id=item.pool.project_id if item.pool else None,
-                adapter_id=item.pool.adapter_id if item.pool else None,
-                position_index=position_index,
-            )
-        else:
-            pool.append_items(items)
+    def _get_tokens(self, raw_balances: list[dict]):
+        symbols = [
+            self._balance_parser.get_symbol(DebankModelBalanceItem(**b))
+            for b in raw_balances
+        ]
 
-        return pool
+        return sorted(symbols)
 
-    def _update_items(
+    def _parse_token_list(
         self,
-        items: List[BalanceItem],
         raw_balances: list[dict],
         asset_type: AssetType,
-        tokens: Optional[List[str]] = None,
-        token_role: Optional[TokenRole] = None,
         pool_id: Optional[str] = None,
-    ):
+    ) -> Iterable[BalanceItem]:
         if not raw_balances:
             return
 
-        if tokens is None:
-            tokens = sorted(
-                list(
-                    set(
-                        [
-                            self._balance_parser.get_symbol(DebankModelBalanceItem(**b))
-                            for b in raw_balances
-                        ]
-                    )
-                )
-            )
-
-        balances = self._balance_parser.parse(
+        yield from self._balance_parser.parse(
             raw_balances,
             asset_type,
             False,
-            token_set=tokens if len(raw_balances) > 1 else None,
-            token_role=token_role,
             pool_id=pool_id,
         )
 
-        items.extend(balances)
-        return tokens
-
     @staticmethod
     def _get_pool_id(item: DebankModelPortfolioItem) -> str:
         return item.pool.id if item.pool else item.pool_id

blockapi/v2/models.py

@@ -363,8 +363,6 @@ class BalanceItem:
     last_updated: Optional[datetime] = attr.ib(default=None)
     protocol: Optional[Protocol] = attr.ib(default=None)
     is_wallet: bool = True
-    token_set: Optional[List[str]] = attr.ib(default=None)
-    token_role: Optional[TokenRole] = attr.ib(default=None)
     pool_id: Optional[str] = attr.ib(default=None)
 
     @classmethod
@@ -378,8 +376,6 @@ def from_api(
         last_updated: Optional[Union[int, str]] = None,
         protocol: Optional[Protocol] = None,
         is_wallet: bool = True,
-        token_set: Optional[List[str]] = None,
-        token_role: Optional[TokenRole] = None,
         pool_id: Optional[str] = None,
     ) -> 'BalanceItem':
         return cls(
@@ -391,8 +387,6 @@ def from_api(
             last_updated=(parse_dt(last_updated) if last_updated is not None else None),
             protocol=protocol,
             is_wallet=is_wallet,
-            token_set=token_set,
-            token_role=token_role,
             pool_id=pool_id,
         )
 
@@ -508,6 +502,7 @@ class Pool:
     project_id: Optional[str] = attr.ib(default=None)
     adapter_id: Optional[str] = attr.ib(default=None)
     position_index: Optional[str] = attr.ib(default=None)
+    tokens: Optional[list[str]] = attr.ib(default=None)
 
     @classmethod
     def from_api(
@@ -522,6 +517,7 @@ def from_api(
         project_id: Optional[str] = None,
         adapter_id: Optional[str] = None,
         position_index: Optional[str] = None,
+        tokens: Optional[list[str]] = None,
     ) -> 'Pool':
         return cls(
             pool_id=pool_id,
@@ -533,6 +529,7 @@ def from_api(
             project_id=project_id,
             adapter_id=adapter_id,
             position_index=position_index,
+            tokens=tokens,
         )
 
     def append_items(self, items: List[BalanceItem]) -> None: