wayfinder-paths 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

wayfinder_paths/__init__.py

@@ -1,13 +1,10 @@
 __version__ = "0.1.0"
 
-# Re-export commonly used items for convenience
 from wayfinder_paths.core import (
     BaseAdapter,
-    LiquidationResult,
     StatusDict,
     StatusTuple,
     Strategy,
-    StrategyJob,
 )
 
 __all__ = [
@@ -16,5 +13,4 @@ __all__ = [
     "Strategy",
     "StatusDict",
     "StatusTuple",
-    "StrategyJob",
 ]

wayfinder_paths/adapters/balance_adapter/README.md

@@ -93,7 +93,6 @@ config = {
 
 ## Dependencies
 
-- `WalletClient` - For balance queries
 - `TokenClient` - For token metadata
 - `LedgerAdapter` - For transaction recording
 - `TokenAdapter` - For price lookups

wayfinder_paths/adapters/balance_adapter/adapter.py

@@ -4,9 +4,8 @@ from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 from wayfinder_paths.adapters.token_adapter.adapter import TokenAdapter
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 from wayfinder_paths.core.clients.TokenClient import TokenClient
-from wayfinder_paths.core.clients.WalletClient import WalletClient
 from wayfinder_paths.core.utils.evm_helpers import resolve_chain_id
-from wayfinder_paths.core.utils.tokens import build_send_transaction
+from wayfinder_paths.core.utils.tokens import build_send_transaction, get_token_balance
 from wayfinder_paths.core.utils.transaction import send_transaction
 
 
@@ -22,61 +21,27 @@ class BalanceAdapter(BaseAdapter):
         super().__init__("balance", config)
         self.main_wallet_signing_callback = main_wallet_signing_callback
         self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
-        self.wallet_client = WalletClient()
         self.token_client = TokenClient()
         self.token_adapter = TokenAdapter()
         self.ledger_adapter = LedgerAdapter()
 
-    def _parse_balance(self, raw: Any) -> int:
-        if raw is None:
-            return 0
-        try:
-            return int(raw)
-        except (ValueError, TypeError):
-            try:
-                return int(float(raw))
-            except (ValueError, TypeError):
-                return 0
-
     async def get_balance(
         self,
         *,
-        query: str | dict[str, Any] | None = None,
-        token_id: str | None = None,
         wallet_address: str,
+        token_id: str | None = None,
+        token_address: str | None = None,
         chain_id: int | None = None,
-    ) -> tuple[bool, str | int]:
-        effective_query = query if query is not None else token_id
-        resolved = (
-            effective_query
-            if isinstance(effective_query, str)
-            else (effective_query or {}).get("token_id")
-        )
-        if not resolved:
-            return (False, "missing query")
+    ) -> tuple[bool, int | str]:
         try:
-            if chain_id is None:
-                token_info = await self.token_client.get_token_details(resolved)
-                if not token_info:
-                    return (False, f"Token not found: {resolved}")
-                resolved_chain_id = resolve_chain_id(token_info, self.logger)
-                if resolved_chain_id is None:
-                    return (False, f"Token {resolved} is missing a chain id")
-                chain_id = resolved_chain_id
-
-            data = await self.wallet_client.get_token_balance_for_address(
-                wallet_address=wallet_address,
-                query=resolved,
-                chain_id=int(chain_id),
-            )
-            raw = (
-                data.get("balance_raw") or data.get("balance")
-                if isinstance(data, dict)
-                else None
-            )
-            return (True, self._parse_balance(raw))
+            if token_id and not token_address:
+                token_info = await self.token_client.get_token_details(token_id)
+                token_address = token_info["address"]
+                chain_id = chain_id or resolve_chain_id(token_info)
+            balance = await get_token_balance(token_address, chain_id, wallet_address)
+            return True, balance
         except Exception as e:
-            return (False, str(e))
+            return False, str(e)
 
     async def move_from_main_wallet_to_strategy_wallet(
         self,
@@ -84,16 +49,17 @@ class BalanceAdapter(BaseAdapter):
         amount: float,
         strategy_name: str = "unknown",
         skip_ledger: bool = False,
-    ) -> tuple[bool, Any]:
+    ) -> tuple[bool, str]:
         return await self._move_between_wallets(
             token_id=token_id,
             amount=amount,
-            from_wallet=self.config.get("main_wallet"),
-            to_wallet=self.config.get("strategy_wallet"),
-            ledger_method=self.ledger_adapter.record_deposit,
+            from_wallet=self.config["main_wallet"],
+            to_wallet=self.config["strategy_wallet"],
+            ledger_method=self.ledger_adapter.record_deposit
+            if not skip_ledger
+            else None,
             ledger_wallet="to",
             strategy_name=strategy_name,
-            skip_ledger=skip_ledger,
         )
 
     async def move_from_strategy_wallet_to_main_wallet(
@@ -102,55 +68,36 @@ class BalanceAdapter(BaseAdapter):
         amount: float,
         strategy_name: str = "unknown",
         skip_ledger: bool = False,
-    ) -> tuple[bool, Any]:
+    ) -> tuple[bool, str]:
         return await self._move_between_wallets(
             token_id=token_id,
             amount=amount,
-            from_wallet=self.config.get("strategy_wallet"),
-            to_wallet=self.config.get("main_wallet"),
-            ledger_method=self.ledger_adapter.record_withdrawal,
+            from_wallet=self.config["strategy_wallet"],
+            to_wallet=self.config["main_wallet"],
+            ledger_method=self.ledger_adapter.record_withdrawal
+            if not skip_ledger
+            else None,
             ledger_wallet="from",
             strategy_name=strategy_name,
-            skip_ledger=skip_ledger,
         )
 
     async def send_to_address(
         self,
         token_id: str,
         amount: int,
-        from_wallet: dict[str, Any] | None,
+        from_wallet: dict[str, Any],
         to_address: str,
-        signing_callback=None,
-        skip_ledger: bool = True,
-    ) -> tuple[bool, Any]:
-        from_address = self._wallet_address(from_wallet)
-        if not from_address:
-            return False, "from_wallet missing or invalid"
-
-        if not to_address:
-            return False, "to_address is required"
-
+        signing_callback,
+    ) -> tuple[bool, str]:
         token_info = await self.token_client.get_token_details(token_id)
-        if not token_info:
-            return False, f"Token not found: {token_id}"
-
-        chain_id = resolve_chain_id(token_info, self.logger)
-        if chain_id is None:
-            return False, f"Token {token_id} is missing chain_id"
-
-        token_address = token_info.get("address")
-
+        chain_id = resolve_chain_id(token_info)
         tx = await build_send_transaction(
-            from_address=from_address,
+            from_address=from_wallet["address"],
             to_address=to_address,
-            token_address=token_address,
+            token_address=token_info["address"],
             chain_id=chain_id,
-            amount=int(amount),
+            amount=amount,
         )
-
-        if not signing_callback:
-            return False, "signing_callback is required"
-
         tx_hash = await send_transaction(tx, signing_callback)
         return True, tx_hash
 
@@ -159,79 +106,63 @@ class BalanceAdapter(BaseAdapter):
         *,
         token_id: str,
         amount: float,
-        from_wallet: dict[str, Any] | None,
-        to_wallet: dict[str, Any] | None,
+        from_wallet: dict[str, Any],
+        to_wallet: dict[str, Any],
         ledger_method,
         ledger_wallet: str,
         strategy_name: str,
-        skip_ledger: bool,
-    ) -> tuple[bool, Any]:
-        from_address = self._wallet_address(from_wallet)
-        to_address = self._wallet_address(to_wallet)
-        if not from_address or not to_address:
-            return False, "main_wallet or strategy_wallet missing"
-
+    ) -> tuple[bool, str]:
         token_info = await self.token_client.get_token_details(token_id)
-        if not token_info:
-            return False, f"Token not found: {token_id}"
-
-        chain_id = resolve_chain_id(token_info, self.logger)
-        if chain_id is None:
-            return False, f"Token {token_id} is missing chain_id"
-
+        chain_id = resolve_chain_id(token_info)
         decimals = token_info.get("decimals", 18)
         raw_amount = int(amount * (10**decimals))
 
-        tx = await build_send_transaction(
-            from_address=from_address,
-            to_address=to_address,
-            token_address=token_info.get("address"),
+        transaction = await build_send_transaction(
+            from_address=from_wallet["address"],
+            to_address=to_wallet["address"],
+            token_address=token_info["address"],
             chain_id=chain_id,
             amount=raw_amount,
         )
-        broadcast_result = await self._send_tx(tx, from_address)
 
-        if broadcast_result[0] and not skip_ledger and ledger_method is not None:
-            wallet_for_ledger = from_address if ledger_wallet == "from" else to_address
+        main_address = self.config.get("main_wallet", {}).get("address", "").lower()
+        callback = (
+            self.main_wallet_signing_callback
+            if from_wallet["address"].lower() == main_address
+            else self.strategy_wallet_signing_callback
+        )
+        tx_hash = await send_transaction(transaction, callback)
+
+        if ledger_method:
+            wallet_for_ledger = (
+                from_wallet["address"]
+                if ledger_wallet == "from"
+                else to_wallet["address"]
+            )
             await self._record_ledger_entry(
-                ledger_method=ledger_method,
-                wallet_address=wallet_for_ledger,
-                token_info=token_info,
-                amount=amount,
-                strategy_name=strategy_name,
+                ledger_method, wallet_for_ledger, token_info, amount, strategy_name
             )
 
-        return broadcast_result
-
-    async def _send_tx(self, tx: dict[str, Any], from_address: str) -> tuple[bool, Any]:
-        main_wallet = self.config.get("main_wallet") or {}
-        main_addr = main_wallet.get("address", "").lower()
-
-        if from_address.lower() == main_addr:
-            callback = self.main_wallet_signing_callback
-        else:
-            callback = self.strategy_wallet_signing_callback
-
-        txn_hash = await send_transaction(tx, callback)
-        return True, txn_hash
+        return True, tx_hash
 
     async def _record_ledger_entry(
         self,
-        *,
         ledger_method,
         wallet_address: str,
         token_info: dict[str, Any],
         amount: float,
         strategy_name: str,
     ) -> None:
-        chain_id = resolve_chain_id(token_info, self.logger)
-        if chain_id is None:
-            return
-
-        usd_value = await self._token_amount_usd(token_info, amount)
         try:
-            token_id = token_info.get("token_id") or token_info.get("id")
-            success, response = await ledger_method(
+            chain_id = resolve_chain_id(token_info)
+            token_id = token_info.get("token_id")
+            usd_value = (
+                await self.token_adapter.get_amount_usd(
+                    token_info.get("token_id"), amount, decimals=0
+                )
+                or 0.0
+            )
+            await ledger_method(
                 wallet_address=wallet_address,
                 chain_id=chain_id,
                 token_address=token_info.get("address"),
@@ -244,40 +175,5 @@ class BalanceAdapter(BaseAdapter):
                 },
                 strategy_name=strategy_name,
             )
-            if not success:
-                self.logger.warning(
-                    "Ledger entry failed",
-                    wallet=wallet_address,
-                    token_id=token_id,
-                    amount=amount,
-                    error=response,
-                )
-        except Exception as exc:  # noqa: BLE001
-            token_id = token_info.get("token_id") or token_info.get("id")
-            self.logger.warning(
-                f"Ledger entry raised: {exc}",
-                wallet=wallet_address,
-                token_id=token_id,
-            )
-
-    async def _token_amount_usd(
-        self, token_info: dict[str, Any], amount: float
-    ) -> float:
-        token_id = token_info.get("token_id")
-        if not token_id:
-            return 0.0
-        success, price_data = await self.token_adapter.get_token_price(token_id)
-        if not success or not price_data:
-            return 0.0
-        return float(price_data.get("current_price", 0.0)) * float(amount)
-
-    def _wallet_address(self, wallet: dict[str, Any] | None) -> str | None:
-        if not wallet:
-            return None
-        address = wallet.get("address")
-        if address:
-            return str(address)
-        evm_wallet = wallet.get("evm") if isinstance(wallet, dict) else None
-        if isinstance(evm_wallet, dict):
-            return evm_wallet.get("address")
-        return None
+        except Exception as exc:
+            self.logger.warning(f"Ledger entry failed: {exc}", wallet=wallet_address)

wayfinder_paths/adapters/balance_adapter/test_adapter.py

@@ -6,27 +6,15 @@ from wayfinder_paths.adapters.balance_adapter.adapter import BalanceAdapter
 
 
 class TestBalanceAdapter:
-    @pytest.fixture
-    def mock_wallet_client(self):
-        mock_client = AsyncMock()
-        return mock_client
-
     @pytest.fixture
     def mock_token_client(self):
-        mock_client = AsyncMock()
-        return mock_client
+        return AsyncMock()
 
     @pytest.fixture
-    def adapter(self, mock_wallet_client, mock_token_client):
-        with (
-            patch(
-                "wayfinder_paths.adapters.balance_adapter.adapter.WalletClient",
-                return_value=mock_wallet_client,
-            ),
-            patch(
-                "wayfinder_paths.adapters.balance_adapter.adapter.TokenClient",
-                return_value=mock_token_client,
-            ),
+    def adapter(self, mock_token_client):
+        with patch(
+            "wayfinder_paths.adapters.balance_adapter.adapter.TokenClient",
+            return_value=mock_token_client,
         ):
             return BalanceAdapter(config={})
 
@@ -45,118 +33,58 @@ class TestBalanceAdapter:
         assert adapter.adapter_type == "BALANCE"
 
     @pytest.mark.asyncio
-    async def test_get_balance_with_query_string(
-        self, adapter, mock_token_client, mock_wallet_client
-    ):
+    async def test_get_balance_with_token_id(self, adapter, mock_token_client):
         mock_token_client.get_token_details = AsyncMock(
             return_value={
                 "token_id": "usd-coin-base",
-                "address": "0x123",
+                "address": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
                 "chain": {"id": 8453, "code": "base"},
             }
         )
-        mock_wallet_client.get_token_balance_for_address = AsyncMock(
-            return_value={"balance": 1000000}
-        )
 
-        success, balance = await adapter.get_balance(
-            query="usd-coin-base",
-            wallet_address="0xWallet",
-        )
-
-        assert success
-        assert balance == 1000000
-        mock_token_client.get_token_details.assert_called_once_with("usd-coin-base")
-        mock_wallet_client.get_token_balance_for_address.assert_called_once_with(
-            wallet_address="0xWallet",
-            query="usd-coin-base",
-            chain_id=8453,
-        )
+        with patch(
+            "wayfinder_paths.adapters.balance_adapter.adapter.get_token_balance",
+            new_callable=AsyncMock,
+            return_value=1000000,
+        ) as mock_get_balance:
+            success, balance = await adapter.get_balance(
+                token_id="usd-coin-base",
+                wallet_address="0xWallet",
+            )
+
+            assert success
+            assert balance == 1000000
+            mock_token_client.get_token_details.assert_called_once_with("usd-coin-base")
+            mock_get_balance.assert_called_once_with(
+                "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", 8453, "0xWallet"
+            )
 
     @pytest.mark.asyncio
-    async def test_get_balance_with_query_dict(
-        self, adapter, mock_token_client, mock_wallet_client
-    ):
-        mock_token_client.get_token_details = AsyncMock(
-            return_value={
-                "token_id": "wsteth-base",
-                "address": "0x456",
-                "chain": {"id": 8453, "code": "base"},
-            }
-        )
-        mock_wallet_client.get_token_balance_for_address = AsyncMock(
-            return_value={"balance": 3000000}
-        )
-
-        success, balance = await adapter.get_balance(
-            query={"token_id": "wsteth-base"},
-            wallet_address="0x123",
-        )
-        assert success
-        assert balance == 3000000
-        mock_token_client.get_token_details.assert_called_once_with("wsteth-base")
-        mock_wallet_client.get_token_balance_for_address.assert_called_once_with(
-            wallet_address="0x123",
-            query="wsteth-base",
-            chain_id=8453,
-        )
-
-    @pytest.mark.asyncio
-    async def test_get_balance_missing_query(self, adapter):
-        success, result = await adapter.get_balance(query={}, wallet_address="0xabc")
-        assert success is False
-        assert "missing query" in str(result)
-
-    @pytest.mark.asyncio
-    async def test_get_balance_with_pool_address(
-        self, adapter, mock_token_client, mock_wallet_client
-    ):
-        mock_wallet_client.get_token_balance_for_address = AsyncMock(
-            return_value={"balance": 5000000}
-        )
-        mock_token_client.get_token_details = AsyncMock()
-
-        success, balance = await adapter.get_balance(
-            query="0xPoolAddress",
-            wallet_address="0xWallet",
-            chain_id=8453,
-        )
-
-        assert success
-        assert balance == 5000000
-        mock_wallet_client.get_token_balance_for_address.assert_called_once_with(
-            wallet_address="0xWallet",
-            query="0xPoolAddress",
-            chain_id=8453,
-        )
-        mock_token_client.get_token_details.assert_not_called()
+    async def test_get_balance_with_token_address(self, adapter, mock_token_client):
+        with patch(
+            "wayfinder_paths.adapters.balance_adapter.adapter.get_token_balance",
+            new_callable=AsyncMock,
+            return_value=5000000,
+        ) as mock_get_balance:
+            success, balance = await adapter.get_balance(
+                token_address="0xTokenAddress",
+                wallet_address="0xWallet",
+                chain_id=8453,
+            )
+
+            assert success
+            assert balance == 5000000
+            mock_get_balance.assert_called_once_with("0xTokenAddress", 8453, "0xWallet")
+            mock_token_client.get_token_details.assert_not_called()
 
     @pytest.mark.asyncio
     async def test_get_balance_token_not_found(self, adapter, mock_token_client):
         mock_token_client.get_token_details = AsyncMock(return_value=None)
 
         success, error = await adapter.get_balance(
-            query="invalid-token",
-            wallet_address="0xWallet",
-        )
-
-        assert success is False
-        assert "Token not found" in str(error)
-
-    @pytest.mark.asyncio
-    async def test_get_balance_missing_chain_id(self, adapter, mock_token_client):
-        mock_token_client.get_token_details = AsyncMock(
-            return_value={
-                "token_id": "token-without-chain",
-                "address": "0x123",
-                "chain": {},
-            }
-        )
-
-        success, error = await adapter.get_balance(
-            query="token-without-chain",
+            token_id="invalid-token",
             wallet_address="0xWallet",
         )
 
         assert success is False
-        assert "missing a chain id" in str(error)
+        assert "NoneType" in error or "subscriptable" in error