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

wayfinder_paths/__init__.py

@@ -2,6 +2,7 @@ __version__ = "0.1.0"
 
 from wayfinder_paths.core import (
     BaseAdapter,
+    LiquidationResult,
     StatusDict,
     StatusTuple,
     Strategy,
@@ -10,6 +11,7 @@ from wayfinder_paths.core import (
 __all__ = [
     "__version__",
     "BaseAdapter",
+    "LiquidationResult",
     "Strategy",
     "StatusDict",
     "StatusTuple",

wayfinder_paths/adapters/balance_adapter/adapter.py

@@ -1,12 +1,17 @@
+import asyncio
 from typing import Any
 
 from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
+from wayfinder_paths.adapters.multicall_adapter.adapter import MulticallAdapter
 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.constants import ZERO_ADDRESS
+from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
 from wayfinder_paths.core.utils.evm_helpers import resolve_chain_id
 from wayfinder_paths.core.utils.tokens import build_send_transaction, get_token_balance
 from wayfinder_paths.core.utils.transaction import send_transaction
+from wayfinder_paths.core.utils.web3 import web3_from_chain_id
 
 
 class BalanceAdapter(BaseAdapter):
@@ -43,6 +48,12 @@ class BalanceAdapter(BaseAdapter):
         except Exception as e:
             return False, str(e)
 
+    async def get_vault_wallet_balance(self, token_id: str) -> tuple[bool, int | str]:
+        addr = self._wallet_address(self.config.get("strategy_wallet", {}))
+        if not addr:
+            return False, "No strategy_wallet configured"
+        return await self.get_balance(wallet_address=addr, token_id=token_id)
+
     async def move_from_main_wallet_to_strategy_wallet(
         self,
         token_id: str,
@@ -177,3 +188,242 @@ class BalanceAdapter(BaseAdapter):
             )
         except Exception as exc:
             self.logger.warning(f"Ledger entry failed: {exc}", wallet=wallet_address)
+
+    @staticmethod
+    def _wallet_address(wallet: dict[str, Any] | None) -> str | None:
+        if wallet and isinstance(wallet, dict):
+            return wallet.get("address")
+        return None
+
+    async def get_wallet_balances_multicall(
+        self,
+        *,
+        assets: list[dict[str, Any]],
+        wallet_address: str | None = None,
+        default_native_decimals: int = 18,
+    ) -> tuple[bool, list[dict[str, Any]] | str]:
+        """
+        Fetch many balances via Multicall3, grouped by chain.
+
+        Each asset entry supports either:
+        - {"token_address": "0x...", "chain_id": 42161}
+        - {"token_id": "usd-coin-arbitrum"} (resolved via TokenClient)
+        Native token entries can use token_address=None/"native"/ZERO_ADDRESS.
+
+        Returns a list aligned with the input `assets`, each containing:
+        - success: bool
+        - chain_id: int | None
+        - token_address: str | None
+        - token_id: str | None
+        - balance_raw: int | None
+        - decimals: int | None
+        - balance_decimal: float | None
+        - error: str | None
+        """
+        if not assets:
+            return True, []
+
+        base_wallet = wallet_address
+        if base_wallet is None:
+            strategy_wallet = self.config.get("strategy_wallet", {})
+            base_wallet = self._wallet_address(strategy_wallet)
+
+        results: list[dict[str, Any]] = [{"success": False} for _ in assets]
+        all_success = True
+
+        normalized: list[dict[str, Any]] = []
+        for idx, asset in enumerate(assets):
+            token_id = asset.get("token_id")
+            token_address = asset.get("token_address")
+            chain_id = asset.get("chain_id")
+            req_wallet = asset.get("wallet_address") or base_wallet
+
+            if not req_wallet:
+                results[idx] = {
+                    "success": False,
+                    "error": "wallet_address not provided and no strategy_wallet configured",
+                    "token_id": token_id,
+                    "token_address": token_address,
+                    "chain_id": chain_id,
+                }
+                all_success = False
+                continue
+
+            # Optionally resolve missing chain/token address via TokenClient.
+            if token_id and (token_address is None or chain_id is None):
+                try:
+                    token_info = await self.token_client.get_token_details(token_id)
+                except Exception as exc:  # noqa: BLE001
+                    token_info = None
+                    self.logger.warning(
+                        f"TokenClient lookup failed for {token_id}: {exc}"
+                    )
+
+                if not token_info:
+                    results[idx] = {
+                        "success": False,
+                        "error": f"Token not found: {token_id}",
+                        "token_id": token_id,
+                        "token_address": token_address,
+                        "chain_id": chain_id,
+                        "wallet_address": req_wallet,
+                    }
+                    all_success = False
+                    continue
+
+                token_address = token_address or token_info.get("address")
+                chain_id = chain_id or resolve_chain_id(token_info)
+
+            if chain_id is None:
+                results[idx] = {
+                    "success": False,
+                    "error": "chain_id is required",
+                    "token_id": token_id,
+                    "token_address": token_address,
+                    "chain_id": chain_id,
+                    "wallet_address": req_wallet,
+                }
+                all_success = False
+                continue
+
+            token_addr_str = (
+                str(token_address).strip() if token_address is not None else None
+            )
+            is_native = (
+                token_addr_str is None
+                or token_addr_str == ""
+                or token_addr_str.lower() == "native"
+                or token_addr_str.lower() == ZERO_ADDRESS.lower()
+            )
+
+            normalized.append(
+                {
+                    "index": idx,
+                    "token_id": token_id,
+                    "token_address": token_addr_str,
+                    "chain_id": int(chain_id),
+                    "wallet_address": str(req_wallet),
+                    "is_native": bool(is_native),
+                }
+            )
+
+        # Group by chain id for separate multicall aggregates.
+        by_chain: dict[int, list[dict[str, Any]]] = {}
+        for entry in normalized:
+            by_chain.setdefault(entry["chain_id"], []).append(entry)
+
+        async def _process_chain(chain_id: int, entries: list[dict[str, Any]]) -> None:
+            nonlocal all_success
+            try:
+                async with web3_from_chain_id(chain_id) as w3:
+                    multicall = MulticallAdapter(web3=w3, chain_id=chain_id)
+
+                    # Deduplicate decimals calls per token (per chain).
+                    token_set: set[str] = {
+                        w3.to_checksum_address(e["token_address"])
+                        for e in entries
+                        if not e["is_native"] and e["token_address"]
+                    }
+                    sorted_tokens = sorted(token_set)
+
+                    calls: list[Any] = []
+                    decimals_call_index: dict[str, int] = {}
+                    for token in sorted_tokens:
+                        erc20 = w3.eth.contract(address=token, abi=ERC20_ABI)
+                        calldata = erc20.encode_abi("decimals")
+                        decimals_call_index[token] = len(calls)
+                        calls.append(multicall.build_call(token, calldata))
+
+                    balance_call_index: dict[int, int] = {}
+                    for entry in entries:
+                        if entry["is_native"]:
+                            call = multicall.encode_eth_balance(entry["wallet_address"])
+                        else:
+                            token = w3.to_checksum_address(entry["token_address"])
+                            call = multicall.encode_erc20_balance(
+                                token, entry["wallet_address"]
+                            )
+                        balance_call_index[entry["index"]] = len(calls)
+                        calls.append(call)
+
+                    mc_res = await multicall.aggregate(calls)
+
+                    decimals_by_token: dict[str, int] = {}
+                    for token, call_idx in decimals_call_index.items():
+                        raw_decimals = multicall.decode_uint256(
+                            mc_res.return_data[call_idx]
+                        )
+                        decimals_by_token[token] = int(raw_decimals)
+
+                    for entry in entries:
+                        out_idx = entry["index"]
+                        bal_idx = balance_call_index[out_idx]
+                        raw_balance = multicall.decode_uint256(
+                            mc_res.return_data[bal_idx]
+                        )
+                        if entry["is_native"]:
+                            decimals = int(default_native_decimals)
+                            token_address_out = None
+                        else:
+                            token = w3.to_checksum_address(entry["token_address"])
+                            decimals = int(
+                                decimals_by_token.get(token, default_native_decimals)
+                            )
+                            token_address_out = token
+
+                        balance_decimal = (
+                            float(raw_balance) / (10**decimals)
+                            if decimals >= 0
+                            else None
+                        )
+
+                        results[out_idx] = {
+                            "success": True,
+                            "token_id": entry.get("token_id"),
+                            "token_address": token_address_out,
+                            "chain_id": chain_id,
+                            "wallet_address": entry["wallet_address"],
+                            "balance_raw": int(raw_balance),
+                            "decimals": int(decimals),
+                            "balance_decimal": float(balance_decimal)
+                            if balance_decimal is not None
+                            else None,
+                            "block_number": mc_res.block_number,
+                        }
+
+            except Exception as exc:  # noqa: BLE001
+                all_success = False
+                err = str(exc)
+                for entry in entries:
+                    out_idx = entry["index"]
+                    results[out_idx] = {
+                        "success": False,
+                        "error": err,
+                        "token_id": entry.get("token_id"),
+                        "token_address": entry.get("token_address"),
+                        "chain_id": chain_id,
+                        "wallet_address": entry.get("wallet_address"),
+                    }
+
+        await asyncio.gather(
+            *[
+                _process_chain(chain_id, entries)
+                for chain_id, entries in by_chain.items()
+            ]
+        )
+
+        # Ensure any leftover placeholder entries are marked failed.
+        for idx, out in enumerate(results):
+            if out.get("success") is True:
+                continue
+            if "error" not in out:
+                all_success = False
+                out.setdefault("error", "Unknown error")
+                out.setdefault("token_id", assets[idx].get("token_id"))
+                out.setdefault("token_address", assets[idx].get("token_address"))
+                out.setdefault("chain_id", assets[idx].get("chain_id"))
+                out.setdefault(
+                    "wallet_address", assets[idx].get("wallet_address") or base_wallet
+                )
+
+        return all_success, results

wayfinder_paths/adapters/balance_adapter/manifest.yaml

@@ -0,0 +1,8 @@
+schema_version: "0.1"
+entrypoint: "adapters.balance_adapter.adapter.BalanceAdapter"
+capabilities:
+  - "balance.read"
+  - "transfer.main_to_strategy"
+  - "transfer.strategy_to_main"
+  - "transfer.send"
+dependencies: []

wayfinder_paths/adapters/balance_adapter/test_adapter.py

@@ -18,17 +18,6 @@ class TestBalanceAdapter:
         ):
             return BalanceAdapter(config={})
 
-    @pytest.mark.asyncio
-    async def test_health_check(self, adapter):
-        health = await adapter.health_check()
-        assert isinstance(health, dict)
-        assert health.get("status") in {"healthy", "unhealthy", "error"}
-
-    @pytest.mark.asyncio
-    async def test_connect(self, adapter):
-        ok = await adapter.connect()
-        assert isinstance(ok, bool)
-
     def test_adapter_type(self, adapter):
         assert adapter.adapter_type == "BALANCE"
 

wayfinder_paths/adapters/boros_adapter/__init__.py

@@ -0,0 +1,17 @@
+"""Boros Adapter - wraps Boros API for fixed-rate market operations."""
+
+from .adapter import BorosAdapter
+from .types import (
+    BorosLimitOrder,
+    BorosMarketQuote,
+    BorosTenorQuote,
+    MarginHealth,
+)
+
+__all__ = [
+    "BorosAdapter",
+    "BorosMarketQuote",
+    "BorosTenorQuote",
+    "BorosLimitOrder",
+    "MarginHealth",
+]