wayfinder-paths 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

wayfinder_paths/core/clients/LedgerClient.py

@@ -5,9 +5,7 @@ import json
 import uuid
 from datetime import UTC, datetime
 from pathlib import Path
-from typing import Any, NotRequired, Required, TypedDict
-
-from wayfinder_paths.core.adapters.models import Operation
+from typing import Any, Literal, NotRequired, Required, TypedDict
 
 
 class StrategyTransaction(TypedDict):
@@ -19,6 +17,8 @@ class StrategyTransaction(TypedDict):
     usd_value: Required[str]
     strategy_name: NotRequired[str | None]
     chain_id: NotRequired[int | None]
+    created: NotRequired[str]
+    op_data: NotRequired[dict[str, Any]]
 
 
 class StrategyTransactionList(TypedDict):
@@ -28,148 +28,197 @@ class StrategyTransactionList(TypedDict):
     offset: Required[int]
 
 
-class NetDeposit(TypedDict):
-    net_deposit: Required[str]
-    total_deposits: Required[str]
-    total_withdrawals: Required[str]
-    wallet_address: NotRequired[str | None]
-
-
 class TransactionRecord(TypedDict):
     transaction_id: Required[str]
     status: Required[str]
     timestamp: Required[str]
 
 
+class OperationData(TypedDict, total=False):
+    type: str
+    transaction_hash: str
+    transaction_chain_id: int
+
+
+class StrategyOperationTransactionData(TypedDict):
+    op_data: OperationData
+
+
 class LedgerClient:
     def __init__(self, ledger_dir: Path | str | None = None) -> None:
         if ledger_dir is None:
-            # Default to .ledger directory in project root
-            project_root = Path(__file__).parent.parent.parent.parent
-            ledger_dir = project_root / ".ledger"
-
+            ledger_dir = Path(__file__).resolve().parents[3] / ".ledger"
         self.ledger_dir = Path(ledger_dir)
         self.ledger_dir.mkdir(parents=True, exist_ok=True)
-
         self.transactions_file = self.ledger_dir / "transactions.json"
         self.snapshots_file = self.ledger_dir / "snapshots.json"
-
-        # File locks for thread-safe operations
         self._transactions_lock = asyncio.Lock()
         self._snapshots_lock = asyncio.Lock()
-
-        # Initialize files if they don't exist
-        self._initialize_files()
-
-    def _initialize_files(self) -> None:
-        if not self.transactions_file.exists():
-            self.transactions_file.write_text(
-                json.dumps({"transactions": []}, indent=2)
-            )
-
-        if not self.snapshots_file.exists():
-            self.snapshots_file.write_text(json.dumps({"snapshots": []}, indent=2))
+        for path, default in [
+            (self.transactions_file, {"transactions": []}),
+            (self.snapshots_file, {"snapshots": []}),
+        ]:
+            if not path.exists():
+                path.write_text(json.dumps(default, indent=2))
+
+    @staticmethod
+    def _load_json_file(path: Path, default: dict[str, Any]) -> dict[str, Any]:
+        if not path.exists():
+            return default
+        try:
+            return json.loads(path.read_text())
+        except json.JSONDecodeError:
+            return default
+
+    @staticmethod
+    def _save_json_file(path: Path, data: dict[str, Any]) -> None:
+        path.write_text(json.dumps(data, indent=2))
+
+    async def _read_json(
+        self, path: Path, lock: asyncio.Lock, default: dict[str, Any]
+    ) -> dict[str, Any]:
+        async with lock:
+            return self._load_json_file(path, default)
+
+    async def _write_json(
+        self, path: Path, lock: asyncio.Lock, data: dict[str, Any]
+    ) -> None:
+        async with lock:
+            self._save_json_file(path, data)
 
     async def _read_transactions(self) -> dict[str, Any]:
-        async with self._transactions_lock:
-            if not self.transactions_file.exists():
-                return {"transactions": []}
-            try:
-                content = self.transactions_file.read_text()
-                return json.loads(content)
-            except json.JSONDecodeError:
-                return {"transactions": []}
+        return await self._read_json(
+            self.transactions_file, self._transactions_lock, {"transactions": []}
+        )
 
     async def _write_transactions(self, data: dict[str, Any]) -> None:
-        async with self._transactions_lock:
-            self.transactions_file.write_text(json.dumps(data, indent=2))
+        await self._write_json(self.transactions_file, self._transactions_lock, data)
 
     async def _read_snapshots(self) -> dict[str, Any]:
-        async with self._snapshots_lock:
-            if not self.snapshots_file.exists():
-                return {"snapshots": []}
-            try:
-                content = self.snapshots_file.read_text()
-                return json.loads(content)
-            except json.JSONDecodeError:
-                return {"snapshots": []}
+        return await self._read_json(
+            self.snapshots_file, self._snapshots_lock, {"snapshots": []}
+        )
 
     async def _write_snapshots(self, data: dict[str, Any]) -> None:
-        async with self._snapshots_lock:
-            self.snapshots_file.write_text(json.dumps(data, indent=2))
-
-    # ===================== Read Endpoints =====================
+        await self._write_json(self.snapshots_file, self._snapshots_lock, data)
 
-    async def get_strategy_transactions(
+    async def _transactions_for_wallet(
         self,
-        *,
         wallet_address: str,
-        limit: int = 100,
-        offset: int = 0,
-    ) -> StrategyTransactionList:
+        *,
+        operation: str | None = None,
+    ) -> list[dict[str, Any]]:
         data = await self._read_transactions()
-        all_transactions = data.get("transactions", [])
-
-        # Filter by wallet_address
-        filtered = [
+        txs = [
             tx
-            for tx in all_transactions
+            for tx in data.get("transactions", [])
             if tx.get("wallet_address", "").lower() == wallet_address.lower()
         ]
+        if operation is not None:
+            txs = [tx for tx in txs if tx.get("operation") == operation]
+        txs.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+        return txs
+
+    def _to_strategy_transaction(self, tx: dict[str, Any]) -> StrategyTransaction:
+        operation = tx["operation"]
+        op_data: dict[str, Any] = {}
+        if operation == "STRAT_OP":
+            op_data = (tx.get("data") or {}).get("op_data") or {}
+        if op_data:
+            operation = op_data.get("type") or operation
+
+        amount = tx["amount"]
+        token_address = tx["token_address"]
+        if op_data:
+            op_type = op_data.get("type", "")
+            if op_type == "SWAP":
+                token_address = op_data.get("to_token_id", "")
+                amount = op_data.get("to_amount", "0")
+            elif op_type in ("LEND", "UNLEND"):
+                token_address = op_data.get("contract", "")
+                amount = str(op_data.get("amount", 0))
+            else:
+                amount = amount or "0"
+                token_address = token_address or ""
+
+        out: StrategyTransaction = {
+            "id": tx["id"],
+            "operation": str(operation),
+            "timestamp": tx["timestamp"],
+            "created": tx["timestamp"],
+            "amount": amount,
+            "token_address": token_address,
+            "usd_value": tx["usd_value"],
+        }
+        if "chain_id" in tx:
+            out["chain_id"] = tx["chain_id"]
+        if "strategy_name" in tx:
+            out["strategy_name"] = tx["strategy_name"]
+        if op_data:
+            out["op_data"] = op_data
+        return out
+
+    @staticmethod
+    def _record(transaction_id: str, timestamp: str) -> TransactionRecord:
+        return {
+            "transaction_id": transaction_id,
+            "status": "success",
+            "timestamp": timestamp,
+        }
 
-        # Sort by timestamp descending (most recent first)
-        filtered.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+    async def _append_transaction(self, transaction: dict[str, Any]) -> None:
+        async with self._transactions_lock:
+            data = self._load_json_file(self.transactions_file, {"transactions": []})
+            data.setdefault("transactions", []).append(transaction)
+            self._save_json_file(self.transactions_file, data)
 
+    async def get_strategy_transactions(
+        self,
+        *,
+        wallet_address: str,
+        limit: int = 50,
+        offset: int = 0,
+        operation: str | None = None,
+    ) -> StrategyTransactionList:
+        filtered = await self._transactions_for_wallet(
+            wallet_address, operation=operation
+        )
         total = len(filtered)
         paginated = filtered[offset : offset + limit]
-
+        transactions = [self._to_strategy_transaction(tx) for tx in paginated]
         return {
-            "transactions": paginated,
+            "transactions": transactions,
             "total": total,
             "limit": limit,
             "offset": offset,
         }
 
     async def get_strategy_net_deposit(self, *, wallet_address: str) -> float:
-        data = await self._read_transactions()
-        all_transactions = data.get("transactions", [])
-
-        # Filter by wallet_address
-        filtered = [
-            tx
-            for tx in all_transactions
-            if tx.get("wallet_address", "").lower() == wallet_address.lower()
-        ]
-
+        filtered = await self._transactions_for_wallet(wallet_address)
         total_deposits = 0.0
         total_withdrawals = 0.0
-
         for tx in filtered:
-            operation = tx.get("operation", "").upper()
-            usd_value = float(tx.get("usd_value", 0))
-
-            if operation == "DEPOSIT":
-                total_deposits += usd_value
-            elif operation == "WITHDRAW":
-                total_withdrawals += usd_value
-
-        net_deposit = total_deposits - total_withdrawals
-
-        return float(net_deposit)
+            op = tx.get("operation", "").upper()
+            usd = float(tx.get("usd_value", 0))
+            if op == "DEPOSIT":
+                total_deposits += usd
+            elif op == "WITHDRAW":
+                total_withdrawals += usd
+        return total_deposits - total_withdrawals
 
     async def get_strategy_latest_transactions(
-        self, *, wallet_address: str, limit: int = 10
+        self, *, wallet_address: str
     ) -> StrategyTransactionList:
         return await self.get_strategy_transactions(
             wallet_address=wallet_address,
-            limit=limit,
+            limit=80,
             offset=0,
+            operation="STRAT_OP",
         )
 
-    # ===================== Write Endpoints =====================
-
-    async def add_strategy_deposit(
+    async def _add_deposit_or_withdraw(
         self,
+        operation: Literal["DEPOSIT", "WITHDRAW"],
         *,
         wallet_address: str,
         chain_id: int,
@@ -181,32 +230,44 @@ class LedgerClient:
     ) -> TransactionRecord:
         transaction_id = str(uuid.uuid4())
         timestamp = datetime.now(UTC).isoformat()
-
-        transaction = {
+        transaction: dict[str, Any] = {
             "id": transaction_id,
             "wallet_address": wallet_address,
-            "operation": "DEPOSIT",
+            "operation": operation,
             "timestamp": timestamp,
-            "chain_id": chain_id,
-            "token_address": token_address,
-            "token_amount": str(token_amount),
             "amount": str(token_amount),
+            "token_address": token_address,
             "usd_value": str(usd_value),
-            "data": data or {},
+            "chain_id": chain_id,
         }
-
+        if data is not None:
+            transaction["data"] = data
         if strategy_name is not None:
             transaction["strategy_name"] = strategy_name
+        await self._append_transaction(transaction)
+        return self._record(transaction_id, timestamp)
 
-        file_data = await self._read_transactions()
-        file_data["transactions"].append(transaction)
-        await self._write_transactions(file_data)
-
-        return {
-            "transaction_id": transaction_id,
-            "status": "success",
-            "timestamp": timestamp,
-        }
+    async def add_strategy_deposit(
+        self,
+        *,
+        wallet_address: str,
+        chain_id: int,
+        token_address: str,
+        token_amount: str | float,
+        usd_value: str | float,
+        data: dict[str, Any] | None = None,
+        strategy_name: str | None = None,
+    ) -> TransactionRecord:
+        return await self._add_deposit_or_withdraw(
+            "DEPOSIT",
+            wallet_address=wallet_address,
+            chain_id=chain_id,
+            token_address=token_address,
+            token_amount=token_amount,
+            usd_value=usd_value,
+            data=data,
+            strategy_name=strategy_name,
+        )
 
     async def add_strategy_withdraw(
         self,
@@ -219,78 +280,47 @@ class LedgerClient:
         data: dict[str, Any] | None = None,
         strategy_name: str | None = None,
     ) -> TransactionRecord:
-        transaction_id = str(uuid.uuid4())
-        timestamp = datetime.now(UTC).isoformat()
-
-        transaction = {
-            "id": transaction_id,
-            "wallet_address": wallet_address,
-            "operation": "WITHDRAW",
-            "timestamp": timestamp,
-            "chain_id": chain_id,
-            "token_address": token_address,
-            "token_amount": str(token_amount),
-            "amount": str(token_amount),
-            "usd_value": str(usd_value),
-            "data": data or {},
-        }
-
-        if strategy_name is not None:
-            transaction["strategy_name"] = strategy_name
-
-        file_data = await self._read_transactions()
-        file_data["transactions"].append(transaction)
-        await self._write_transactions(file_data)
-
-        return {
-            "transaction_id": transaction_id,
-            "status": "success",
-            "timestamp": timestamp,
-        }
+        return await self._add_deposit_or_withdraw(
+            "WITHDRAW",
+            wallet_address=wallet_address,
+            chain_id=chain_id,
+            token_address=token_address,
+            token_amount=token_amount,
+            usd_value=usd_value,
+            data=data,
+            strategy_name=strategy_name,
+        )
 
     async def add_strategy_operation(
         self,
         *,
         wallet_address: str,
-        operation_data: Operation,
+        operation_data: dict[str, Any],
         usd_value: str | float,
         strategy_name: str | None = None,
     ) -> TransactionRecord:
         transaction_id = str(uuid.uuid4())
         timestamp = datetime.now(UTC).isoformat()
-
-        op_dict = operation_data.model_dump(mode="json")
-        operation_type = op_dict.get("type", "OPERATION")
-
-        transaction = {
+        transaction: dict[str, Any] = {
             "id": transaction_id,
             "wallet_address": wallet_address,
-            "operation": operation_type,
+            "operation": "STRAT_OP",
             "timestamp": timestamp,
+            "amount": "0",
+            "token_address": "",
             "usd_value": str(usd_value),
-            "op_data": op_dict,
-            "data": {},
+            "data": {"op_data": operation_data},
         }
-
-        if operation_type == "SWAP":
-            transaction["token_address"] = op_dict.get("to_token_id", "")
-            transaction["amount"] = op_dict.get("to_amount", "0")
-        elif operation_type in ("LEND", "UNLEND"):
-            transaction["token_address"] = op_dict.get("contract", "")
-            transaction["amount"] = str(op_dict.get("amount", 0))
-
         if strategy_name is not None:
             transaction["strategy_name"] = strategy_name
+        await self._append_transaction(transaction)
+        return self._record(transaction_id, timestamp)
 
-        file_data = await self._read_transactions()
-        file_data["transactions"].append(transaction)
-        await self._write_transactions(file_data)
-
-        return {
-            "transaction_id": transaction_id,
-            "status": "success",
-            "timestamp": timestamp,
-        }
+    async def _append_snapshot(self, snapshot: dict[str, Any]) -> None:
+        async with self._snapshots_lock:
+            data = self._load_json_file(self.snapshots_file, {"snapshots": []})
+            data.setdefault("snapshots", []).append(snapshot)
+            self._save_json_file(self.snapshots_file, data)
 
     async def strategy_snapshot(
         self,
@@ -301,20 +331,14 @@ class LedgerClient:
         gas_available: float,
         gassed_up: bool,
     ) -> None:
-        snapshot_id = str(uuid.uuid4())
-        timestamp = datetime.now(UTC).isoformat()
-
         snapshot = {
-            "id": snapshot_id,
+            "id": str(uuid.uuid4()),
             "wallet_address": wallet_address,
-            "timestamp": timestamp,
+            "timestamp": datetime.now(UTC).isoformat(),
             "portfolio_value": strat_portfolio_value,
             "net_deposit": net_deposit,
             "gas_available": gas_available,
             "gassed_up": gassed_up,
             "strategy_status": strategy_status,
         }
-
-        file_data = await self._read_snapshots()
-        file_data["snapshots"].append(snapshot)
-        await self._write_snapshots(file_data)
+        await self._append_snapshot(snapshot)

wayfinder_paths/core/clients/TokenClient.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import xml.etree.ElementTree as ET
 from typing import NotRequired, Required, TypedDict
 
 from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
@@ -76,10 +77,20 @@ class GasToken(TypedDict):
     chain: NotRequired[ChainInfo]
 
 
+class FuzzyTokenResult(TypedDict):
+    coingecko_id: NotRequired[str]
+    address: NotRequired[str]
+    chain: NotRequired[str]
+    name: NotRequired[str]
+    symbol: NotRequired[str]
+    price: NotRequired[float]
+    confidence: NotRequired[int]
+
+
 class TokenClient(WayfinderClient):
     def __init__(self):
         super().__init__()
-        self.api_base_url = f"{get_api_base_url()}/v1/blockchain/tokens"
+        self.api_base_url = f"{get_api_base_url()}/blockchain/tokens"
 
     async def get_token_details(
         self, query: str, market_data: bool = False, chain_id: int | None = None
@@ -103,3 +114,38 @@ class TokenClient(WayfinderClient):
         response.raise_for_status()
         data = response.json()
         return data.get("data", data)
+
+    async def fuzzy_search(
+        self, query: str, chain: str | None = None
+    ) -> dict[str, list[FuzzyTokenResult] | str | None]:
+        url = f"{self.api_base_url}/fuzzy/"
+        params: dict[str, str] = {"query": query}
+        if chain:
+            params["chain"] = chain
+        response = await self._authed_request("GET", url, params=params)
+        response.raise_for_status()
+        trace_id = response.headers.get("X-Token-Fuzzy-Trace")
+        tokens = self._parse_fuzzy_xml(response.text)
+        return {"tokens": tokens, "trace_id": trace_id}
+
+    def _parse_fuzzy_xml(self, xml_content: str) -> list[FuzzyTokenResult]:
+        root = ET.fromstring(xml_content)
+        tokens: list[FuzzyTokenResult] = []
+        for token_elem in root.findall("token"):
+            token: FuzzyTokenResult = {}
+            for field in ["coingecko_id", "address", "chain", "name", "symbol"]:
+                elem = token_elem.find(field)
+                if elem is not None and elem.text:
+                    token[field] = elem.text  # type: ignore[literal-required]
+            for num_field in ["price", "confidence"]:
+                elem = token_elem.find(num_field)
+                if elem is not None and elem.text:
+                    try:
+                        if num_field == "price":
+                            token["price"] = float(elem.text)
+                        else:
+                            token["confidence"] = int(elem.text)
+                    except ValueError:
+                        pass
+            tokens.append(token)
+        return tokens

wayfinder_paths/core/clients/WayfinderClient.py

@@ -60,14 +60,12 @@ class WayfinderClient:
         url: str,
         *,
         headers: dict[str, str] | None = None,
-        retry_on_401: bool = False,
         **kwargs: Any,
     ) -> httpx.Response:
         logger.debug(f"Making {method} request to {url}")
         start_time = time.time()
 
-        # Ensure API key is set in headers if available and not already set
-        # This ensures API keys are passed to all endpoints (including public ones) for rate limiting
+        # Pass API key to all endpoints (including public ones) for rate limiting
         if not self.headers.get("X-API-KEY"):
             creds = self._load_config_credentials()
             api_key = creds.get("api_key")

wayfinder_paths/core/clients/__init__.py

@@ -9,26 +9,21 @@ from wayfinder_paths.core.clients.protocols import (
     LedgerClientProtocol,
     PoolClientProtocol,
     TokenClientProtocol,
-    WalletClientProtocol,
 )
 from wayfinder_paths.core.clients.TokenClient import TokenClient
-from wayfinder_paths.core.clients.WalletClient import WalletClient
 from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
 
 __all__ = [
     "WayfinderClient",
     "ClientManager",
     "TokenClient",
-    "WalletClient",
     "LedgerClient",
     "PoolClient",
     "BRAPClient",
     "HyperlendClient",
-    # Protocols for SDK usage
     "TokenClientProtocol",
     "HyperlendClientProtocol",
     "LedgerClientProtocol",
-    "WalletClientProtocol",
     "PoolClientProtocol",
     "BRAPClientProtocol",
 ]

wayfinder_paths/core/clients/protocols.py

@@ -1,30 +1,26 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Protocol
-
-if TYPE_CHECKING:
-    from wayfinder_paths.core.clients.BRAPClient import BRAPQuoteResponse
-    from wayfinder_paths.core.clients.HyperlendClient import (
-        AssetsView,
-        LendRateHistory,
-        MarketEntry,
-        StableMarketsHeadroomResponse,
-    )
-    from wayfinder_paths.core.clients.LedgerClient import (
-        StrategyTransactionList,
-        TransactionRecord,
-    )
-    from wayfinder_paths.core.clients.PoolClient import (
-        LlamaMatchesResponse,
-        PoolList,
-    )
-    from wayfinder_paths.core.clients.TokenClient import (
-        GasToken,
-        TokenDetails,
-    )
-    from wayfinder_paths.core.clients.WalletClient import (
-        AddressBalance,
-    )
+from typing import Any, Protocol
+
+from wayfinder_paths.core.clients.BRAPClient import BRAPQuoteResponse
+from wayfinder_paths.core.clients.HyperlendClient import (
+    AssetsView,
+    LendRateHistory,
+    MarketEntry,
+    StableMarketsHeadroomResponse,
+)
+from wayfinder_paths.core.clients.LedgerClient import (
+    StrategyTransactionList,
+    TransactionRecord,
+)
+from wayfinder_paths.core.clients.PoolClient import (
+    LlamaMatchesResponse,
+    PoolList,
+)
+from wayfinder_paths.core.clients.TokenClient import (
+    GasToken,
+    TokenDetails,
+)
 
 
 class TokenClientProtocol(Protocol):
@@ -117,16 +113,6 @@ class LedgerClientProtocol(Protocol):
     ) -> TransactionRecord: ...
 
 
-class WalletClientProtocol(Protocol):
-    async def get_token_balance_for_address(
-        self,
-        *,
-        wallet_address: str,
-        query: str,
-        chain_id: int | None = None,
-    ) -> AddressBalance: ...
-
-
 class PoolClientProtocol(Protocol):
     async def get_pools_by_ids(
         self,