wayfinder-paths 0.1.22__py3-none-any.whl → 0.1.24__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

@@ -1,13 +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.clients.WalletClient import WalletClient
+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
+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):
@@ -22,61 +26,33 @@ 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 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,
@@ -84,16 +60,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 +79,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 +117,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 +186,244 @@ 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,
-            )
+        except Exception as exc:
+            self.logger.warning(f"Ledger entry failed: {exc}", wallet=wallet_address)
 
-    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")
+    @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: []