wayfinder-paths 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

wayfinder_paths/adapters/ledger_adapter/README.md

@@ -1,15 +1,15 @@
 # Ledger Adapter
 
-A Wayfinder adapter that provides high-level operations for vault transaction history and bookkeeping. This adapter wraps the `LedgerClient` to offer strategy-friendly methods for recording and retrieving vault operations.
+A Wayfinder adapter that provides high-level operations for strategy transaction history and bookkeeping. This adapter wraps the `LedgerClient` to offer strategy-friendly methods for recording and retrieving strategy operations.
 
 ## Capabilities
 
-- `ledger.read`: Read vault transaction data and net deposits
+- `ledger.read`: Read strategy transaction data and net deposits
 - `ledger.write`: Record deposits, withdrawals, and operations
-- `vault.transactions`: Access vault transaction history
-- `vault.deposits`: Record deposit transactions
-- `vault.withdrawals`: Record withdrawal transactions
-- `vault.operations`: Record vault operations (swaps, rebalances, etc.)
+- `strategy.transactions`: Access strategy transaction history
+- `strategy.deposits`: Record deposit transactions
+- `strategy.withdrawals`: Record withdrawal transactions
+- `strategy.operations`: Record strategy operations (swaps, rebalances, etc.)
 
 ## Configuration
 
@@ -31,10 +31,10 @@ from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 adapter = LedgerAdapter()
 ```
 
-### Get Vault Transaction History
+### Get Strategy Transaction History
 
 ```python
-success, data = await adapter.get_vault_transactions(
+success, data = await adapter.get_strategy_transactions(
     wallet_address="0x1234567890123456789012345678901234567890",
     limit=10,
     offset=0
@@ -49,7 +49,7 @@ else:
 ### Get Net Deposit Amount
 
 ```python
-success, data = await adapter.get_vault_net_deposit(
+success, data = await adapter.get_strategy_net_deposit(
     wallet_address="0x1234567890123456789012345678901234567890"
 )
 if success:
@@ -93,51 +93,38 @@ else:
     print(f"Error: {data}")
 ```
 
-### Record an Operation or Cashflow
+### Record an Operation
 
 ```python
+from wayfinder_paths.adapters.ledger_adapter.models import SWAP
+
+operation = SWAP(
+    from_token_id="0xA0b86...",
+    to_token_id="0xB1c97...",
+    from_amount="1000000000000000000",
+    to_amount="995000000000000000",
+    from_amount_usd=1000.0,
+    to_amount_usd=995.0,
+)
+
 success, op = await adapter.record_operation(
-    wallet_address=vault_address,
-    operation_data={
-        "type": "SWAP",
-        "from_token": "...",
-        "to_token": "...",
-        "amount_in": "1000000000000000000",
-        "amount_out": "995000000000000000",
-    },
+    wallet_address=strategy_address,
+    operation_data=operation,
     usd_value="1000.00",
     strategy_name="StablecoinYieldStrategy",
 )
 
-success, cashflow = await adapter.record_cashflow(
-    wallet_address=vault_address,
-    block_timestamp=int(time.time()),
-    token_addr="0x...",
-    amount="250000000000000000",
-    description="reward",
-    strategy_name="StablecoinYieldStrategy",
-)
 ```
 
 ### Latest Transactions and Summaries
 
 ```python
-success, latest = await adapter.get_vault_latest_transactions(wallet_address=vault_address)
-success, summary = await adapter.get_transaction_summary(wallet_address=vault_address, limit=5)
+success, latest = await adapter.get_strategy_latest_transactions(wallet_address=strategy_address)
+success, summary = await adapter.get_transaction_summary(wallet_address=strategy_address, limit=5)
 if success:
     print(f"Total transactions: {summary.get('total_transactions')}")
 ```
 
-## API Endpoints
-
-The adapter uses the following Wayfinder API endpoints:
-
-- `GET /api/v1/public/vaults/transactions/` - Get vault transactions
-- `GET /api/v1/public/vaults/net-deposit/` - Get net deposit amount
-- `POST /api/v1/public/vaults/deposits/` - Record a deposit
-- `POST /api/v1/public/vaults/withdrawals/` - Record a withdrawal
-- `POST /api/v1/public/vaults/operations/` - Record an operation
-
 ## Error Handling
 
 All methods return a tuple of `(success: bool, data: Any)` where:
@@ -149,7 +136,7 @@ All methods return a tuple of `(success: bool, data: Any)` where:
 Run the adapter tests:
 
 ```bash
-pytest wayfinder_paths/vaults/adapters/ledger_adapter/test_adapter.py -v
+pytest wayfinder_paths/adapters/ledger_adapter/test_adapter.py -v
 ```
 
 ## Dependencies

wayfinder_paths/adapters/ledger_adapter/adapter.py

@@ -1,18 +1,25 @@
 from typing import Any
 
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
-from wayfinder_paths.core.clients.LedgerClient import LedgerClient
+from wayfinder_paths.core.adapters.models import Operation
+from wayfinder_paths.core.clients.LedgerClient import (
+    LedgerClient,
+    NetDeposit,
+    StrategyTransactionList,
+    TransactionRecord,
+)
+from wayfinder_paths.core.strategies.Strategy import StatusDict
 
 
 class LedgerAdapter(BaseAdapter):
     """
-    Ledger adapter for vault transaction history and bookkeeping operations.
+    Ledger adapter for strategy transaction history and bookkeeping operations.
 
     Provides high-level operations for:
-    - Fetching vault transaction history
+    - Fetching strategy transaction history
     - Getting net deposit amounts
     - Getting last rotation time
-    - Recording deposits, withdrawals, operations, and cashflows
+    - Recording deposits, withdrawals, and operations
     """
 
     adapter_type: str = "LEDGER"
@@ -25,14 +32,14 @@ class LedgerAdapter(BaseAdapter):
         super().__init__("ledger_adapter", config)
         self.ledger_client = ledger_client or LedgerClient()
 
-    async def get_vault_transactions(
+    async def get_strategy_transactions(
         self, wallet_address: str, limit: int = 50, offset: int = 0
-    ) -> tuple[bool, Any]:
+    ) -> tuple[bool, StrategyTransactionList | str]:
         """
-        Get paginated vault transaction history.
+        Get paginated strategy transaction history.
 
         Args:
-            wallet_address: Vault wallet address
+            wallet_address: Strategy wallet address
             limit: Maximum number of transactions to return
             offset: Number of transactions to skip
 
@@ -40,52 +47,54 @@ class LedgerAdapter(BaseAdapter):
             Tuple of (success, data) where data is transaction list or error message
         """
         try:
-            data = await self.ledger_client.get_vault_transactions(
+            data = await self.ledger_client.get_strategy_transactions(
                 wallet_address=wallet_address, limit=limit, offset=offset
             )
             return (True, data)
         except Exception as e:
-            self.logger.error(f"Error fetching vault transactions: {e}")
+            self.logger.error(f"Error fetching strategy transactions: {e}")
             return (False, str(e))
 
-    async def get_vault_net_deposit(self, wallet_address: str) -> tuple[bool, Any]:
+    async def get_strategy_net_deposit(
+        self, wallet_address: str
+    ) -> tuple[bool, NetDeposit | str]:
         """
-        Get net deposit amount (deposits - withdrawals) for a vault.
+        Get net deposit amount (deposits - withdrawals) for a strategy.
 
         Args:
-            wallet_address: Vault wallet address
+            wallet_address: Strategy wallet address
 
         Returns:
             Tuple of (success, data) where data contains net_deposit or error message
         """
         try:
-            data = await self.ledger_client.get_vault_net_deposit(
+            data = await self.ledger_client.get_strategy_net_deposit(
                 wallet_address=wallet_address
             )
             return (True, data)
         except Exception as e:
-            self.logger.error(f"Error fetching vault net deposit: {e}")
+            self.logger.error(f"Error fetching strategy net deposit: {e}")
             return (False, str(e))
 
-    async def get_vault_latest_transactions(
+    async def get_strategy_latest_transactions(
         self, wallet_address: str
-    ) -> tuple[bool, Any]:
+    ) -> tuple[bool, StrategyTransactionList | str]:
         """
-        Get the latest transactions for a vault.
+        Get the latest transactions for a strategy.
 
         Args:
-            wallet_address: Vault wallet address
+            wallet_address: Strategy wallet address
 
         Returns:
             Tuple of (success, data) where data contains latest transactions or error message
         """
         try:
-            data = await self.ledger_client.get_vault_latest_transactions(
+            data = await self.ledger_client.get_strategy_latest_transactions(
                 wallet_address=wallet_address
             )
             return (True, data)
         except Exception as e:
-            self.logger.error(f"Error fetching vault last transactions: {e}")
+            self.logger.error(f"Error fetching strategy last transactions: {e}")
             return (False, str(e))
 
     async def record_deposit(
@@ -97,12 +106,12 @@ class LedgerAdapter(BaseAdapter):
         usd_value: str | float,
         data: dict[str, Any] | None = None,
         strategy_name: str | None = None,
-    ) -> tuple[bool, Any]:
+    ) -> tuple[bool, TransactionRecord | str]:
         """
-        Record a vault deposit transaction.
+        Record a strategy deposit transaction.
 
         Args:
-            wallet_address: Vault wallet address
+            wallet_address: Strategy wallet address
             chain_id: Blockchain chain ID
             token_address: Token contract address
             token_amount: Amount deposited (in token units)
@@ -114,7 +123,7 @@ class LedgerAdapter(BaseAdapter):
             Tuple of (success, data) where data is transaction record or error message
         """
         try:
-            result = await self.ledger_client.add_vault_deposit(
+            result = await self.ledger_client.add_strategy_deposit(
                 wallet_address=wallet_address,
                 chain_id=chain_id,
                 token_address=token_address,
@@ -137,12 +146,12 @@ class LedgerAdapter(BaseAdapter):
         usd_value: str | float,
         data: dict[str, Any] | None = None,
         strategy_name: str | None = None,
-    ) -> tuple[bool, Any]:
+    ) -> tuple[bool, TransactionRecord | str]:
         """
-        Record a vault withdrawal transaction.
+        Record a strategy withdrawal transaction.
 
         Args:
-            wallet_address: Vault wallet address
+            wallet_address: Strategy wallet address
             chain_id: Blockchain chain ID
             token_address: Token contract address
             token_amount: Amount withdrawn (in token units)
@@ -154,7 +163,7 @@ class LedgerAdapter(BaseAdapter):
             Tuple of (success, data) where data is transaction record or error message
         """
         try:
-            result = await self.ledger_client.add_vault_withdraw(
+            result = await self.ledger_client.add_strategy_withdraw(
                 wallet_address=wallet_address,
                 chain_id=chain_id,
                 token_address=token_address,
@@ -171,16 +180,16 @@ class LedgerAdapter(BaseAdapter):
     async def record_operation(
         self,
         wallet_address: str,
-        operation_data: dict[str, Any],
+        operation_data: Operation,
         usd_value: str | float,
         strategy_name: str | None = None,
-    ) -> tuple[bool, Any]:
+    ) -> tuple[bool, TransactionRecord | str]:
         """
-        Record a vault operation (e.g., swaps, rebalances) for bookkeeping.
+        Record a strategy operation (e.g., swaps, rebalances) for bookkeeping.
 
         Args:
-            wallet_address: Vault wallet address
-            operation_data: Details of the operation performed
+            wallet_address: Strategy wallet address
+            operation_data: Operation model (SWAP, LEND, BORROW, etc.)
             usd_value: USD value of the operation
             strategy_name: Name of the strategy performing the operation
 
@@ -188,7 +197,7 @@ class LedgerAdapter(BaseAdapter):
             Tuple of (success, data) where data is operation record or error message
         """
         try:
-            result = await self.ledger_client.add_vault_operation(
+            result = await self.ledger_client.add_strategy_operation(
                 wallet_address=wallet_address,
                 operation_data=operation_data,
                 usd_value=usd_value,
@@ -199,58 +208,21 @@ class LedgerAdapter(BaseAdapter):
             self.logger.error(f"Error recording operation: {e}")
             return (False, str(e))
 
-    async def record_cashflow(
-        self,
-        wallet_address: str,
-        block_timestamp: int,
-        token_addr: str,
-        amount: str | int | float,
-        description: str,
-        strategy_name: str | None = None,
-    ) -> tuple[bool, Any]:
-        """
-        Record a vault cashflow (interest, funding, reward, or fee).
-
-        Args:
-            wallet_address: Vault wallet address
-            block_timestamp: Block timestamp (Unix timestamp)
-            token_addr: Token contract address
-            amount: Cashflow amount (in token units)
-            description: Cashflow type - must be one of: "interest", "funding", "reward", "fee"
-            strategy_name: Optional strategy name
-
-        Returns:
-            Tuple of (success, data) where data is cashflow record or error message
-        """
-        try:
-            result = await self.ledger_client.add_vault_cashflow(
-                wallet_address=wallet_address,
-                block_timestamp=block_timestamp,
-                token_addr=token_addr,
-                amount=amount,
-                description=description,
-                strategy_name=strategy_name,
-            )
-            return (True, result)
-        except Exception as e:
-            self.logger.error(f"Error recording cashflow: {e}")
-            return (False, str(e))
-
     async def get_transaction_summary(
         self, wallet_address: str, limit: int = 10
     ) -> tuple[bool, Any]:
         """
-        Get a summary of recent vault transactions.
+        Get a summary of recent strategy transactions.
 
         Args:
-            wallet_address: Vault wallet address
+            wallet_address: Strategy wallet address
             limit: Number of recent transactions to include
 
         Returns:
             Tuple of (success, data) where data is transaction summary or error message
         """
         try:
-            success, transactions_data = await self.get_vault_transactions(
+            success, transactions_data = await self.get_strategy_transactions(
                 wallet_address=wallet_address, limit=limit
             )
 
@@ -284,3 +256,34 @@ class LedgerAdapter(BaseAdapter):
         except Exception as e:
             self.logger.error(f"Error creating transaction summary: {e}")
             return (False, str(e))
+
+    async def record_strategy_snapshot(
+        self, wallet_address: str, strategy_status: StatusDict
+    ) -> tuple[bool, None | str]:
+        """
+        Record a strategy snapshot with current state.
+
+        Args:
+            wallet_address: Strategy wallet address
+            strat_portfolio_value: Current portfolio value
+            net_deposit: Net deposit amount
+            strategy_status: Current strategy status dictionary
+            gas_available: Available gas amount
+            gassed_up: Whether the strategy is gassed up
+
+        Returns:
+            Tuple of (success, None) on success or (False, error_message) on failure
+        """
+        try:
+            await self.ledger_client.strategy_snapshot(
+                wallet_address=wallet_address,
+                strat_portfolio_value=strategy_status["portfolio_value"],
+                net_deposit=strategy_status["net_deposit"],
+                strategy_status=strategy_status["strategy_status"],
+                gas_available=strategy_status["gas_available"],
+                gassed_up=strategy_status["gassed_up"],
+            )
+            return (True, None)
+        except Exception as e:
+            self.logger.error(f"Error recording strategy snapshot: {e}")
+            return (False, str(e))

wayfinder_paths/adapters/ledger_adapter/examples.json

@@ -80,14 +80,20 @@
   },
   "record_operation": {
     "description": "Record a vault operation (swap, rebalance, etc.)",
+    "note": "operation_data must be a Pydantic Operation model (currently only SWAP is implemented)",
     "input": {
       "wallet_address": "0x1234567890123456789012345678901234567890",
       "operation_data": {
         "type": "SWAP",
-        "from_token": "0xA0b86a33E6441c8C06DdD4D4c4c4c4c4c4c4c4c4c",
-        "to_token": "0xB1c97a44F7552d9Dd5e5e5e5e5e5e5e5e5e5e5e5e5e",
-        "amount_in": "1000000000000000000",
-        "amount_out": "995000000000000000"
+        "from_token_id": "0xA0b86a33E6441c8C06DdD4D4c4c4c4c4c4c4c4c4c",
+        "to_token_id": "0xB1c97a44F7552d9Dd5e5e5e5e5e5e5e5e5e5e5e5e5e",
+        "from_amount": "1000000000000000000",
+        "to_amount": "995000000000000000",
+        "from_amount_usd": 1000.0,
+        "to_amount_usd": 995.0,
+        "transaction_hash": "0xabcdef...",
+        "transaction_status": "success",
+        "transaction_receipt": null
       },
       "usd_value": "1000.00",
       "strategy_name": "StablecoinYieldStrategy"

wayfinder_paths/adapters/ledger_adapter/manifest.yaml

@@ -3,9 +3,9 @@ entrypoint: "adapters.ledger_adapter.adapter.LedgerAdapter"
 capabilities:
   - "ledger.read"
   - "ledger.write"
-  - "vault.transactions"
-  - "vault.deposits"
-  - "vault.withdrawals"
-  - "vault.operations"
+  - "strategy.transactions"
+  - "strategy.deposits"
+  - "strategy.withdrawals"
+  - "strategy.operations"
 dependencies:
   - "LedgerClient"

wayfinder_paths/adapters/ledger_adapter/test_adapter.py

@@ -24,8 +24,8 @@ class TestLedgerAdapter:
             return LedgerAdapter()
 
     @pytest.mark.asyncio
-    async def test_get_vault_transactions_success(self, adapter, mock_ledger_client):
-        """Test successful vault transaction retrieval"""
+    async def test_get_strategy_transactions_success(self, adapter, mock_ledger_client):
+        """Test successful strategy transaction retrieval"""
         mock_response = {
             "transactions": [
                 {
@@ -37,11 +37,11 @@ class TestLedgerAdapter:
             ],
             "total": 1,
         }
-        mock_ledger_client.get_vault_transactions = AsyncMock(
+        mock_ledger_client.get_strategy_transactions = AsyncMock(
             return_value=mock_response
         )
 
-        success, data = await adapter.get_vault_transactions(
+        success, data = await adapter.get_strategy_transactions(
             wallet_address="0x1234567890123456789012345678901234567890",
             limit=10,
             offset=0,
@@ -49,20 +49,20 @@ class TestLedgerAdapter:
 
         assert success is True
         assert data == mock_response
-        mock_ledger_client.get_vault_transactions.assert_called_once_with(
+        mock_ledger_client.get_strategy_transactions.assert_called_once_with(
             wallet_address="0x1234567890123456789012345678901234567890",
             limit=10,
             offset=0,
         )
 
     @pytest.mark.asyncio
-    async def test_get_vault_transactions_failure(self, adapter, mock_ledger_client):
-        """Test vault transaction retrieval failure"""
-        mock_ledger_client.get_vault_transactions = AsyncMock(
+    async def test_get_strategy_transactions_failure(self, adapter, mock_ledger_client):
+        """Test strategy transaction retrieval failure"""
+        mock_ledger_client.get_strategy_transactions = AsyncMock(
             side_effect=Exception("API Error")
         )
 
-        success, data = await adapter.get_vault_transactions(
+        success, data = await adapter.get_strategy_transactions(
             wallet_address="0x1234567890123456789012345678901234567890"
         )
 
@@ -70,23 +70,25 @@ class TestLedgerAdapter:
         assert "API Error" in data
 
     @pytest.mark.asyncio
-    async def test_get_vault_net_deposit_success(self, adapter, mock_ledger_client):
-        """Test successful vault net deposit retrieval"""
+    async def test_get_strategy_net_deposit_success(self, adapter, mock_ledger_client):
+        """Test successful strategy net deposit retrieval"""
         mock_response = {
             "net_deposit": "1000.00",
             "total_deposits": "1500.00",
             "total_withdrawals": "500.00",
         }
-        mock_ledger_client.get_vault_net_deposit = AsyncMock(return_value=mock_response)
+        mock_ledger_client.get_strategy_net_deposit = AsyncMock(
+            return_value=mock_response
+        )
 
         # Test
-        success, data = await adapter.get_vault_net_deposit(
+        success, data = await adapter.get_strategy_net_deposit(
             wallet_address="0x1234567890123456789012345678901234567890"
         )
 
         assert success is True
         assert data == mock_response
-        mock_ledger_client.get_vault_net_deposit.assert_called_once_with(
+        mock_ledger_client.get_strategy_net_deposit.assert_called_once_with(
             wallet_address="0x1234567890123456789012345678901234567890"
         )
 
@@ -98,7 +100,7 @@ class TestLedgerAdapter:
             "status": "recorded",
             "timestamp": "2024-01-15T10:30:00Z",
         }
-        mock_ledger_client.add_vault_deposit.return_value = mock_response
+        mock_ledger_client.add_strategy_deposit.return_value = mock_response
 
         # Test
         success, data = await adapter.record_deposit(
@@ -112,7 +114,7 @@ class TestLedgerAdapter:
 
         assert success is True
         assert data == mock_response
-        mock_ledger_client.add_vault_deposit.assert_called_once_with(
+        mock_ledger_client.add_strategy_deposit.assert_called_once_with(
             wallet_address="0x1234567890123456789012345678901234567890",
             chain_id=8453,
             token_address="0xA0b86a33E6441c8C06DdD4D4c4c4c4c4c4c4c4c4c",
@@ -130,7 +132,7 @@ class TestLedgerAdapter:
             "status": "recorded",
             "timestamp": "2024-01-15T11:00:00Z",
         }
-        mock_ledger_client.add_vault_withdraw.return_value = mock_response
+        mock_ledger_client.add_strategy_withdraw.return_value = mock_response
 
         # Test
         success, data = await adapter.record_withdrawal(
@@ -148,21 +150,24 @@ class TestLedgerAdapter:
     @pytest.mark.asyncio
     async def test_record_operation_success(self, adapter, mock_ledger_client):
         """Test successful operation recording"""
+        from wayfinder_paths.core.adapters.models import SWAP
+
         mock_response = {
             "operation_id": "op_123",
             "status": "recorded",
             "timestamp": "2024-01-15T10:45:00Z",
         }
-        mock_ledger_client.add_vault_operation.return_value = mock_response
+        mock_ledger_client.add_strategy_operation.return_value = mock_response
 
         # Test
-        operation_data = {
-            "type": "SWAP",
-            "from_token": "0xA0b86a33E6441c8C06DdD4D4c4c4c4c4c4c4c4c4c",
-            "to_token": "0xB1c97a44F7552d9Dd5e5e5e5e5e5e5e5e5e5e5e5e5e",
-            "amount_in": "1000000000000000000",
-            "amount_out": "995000000000000000",
-        }
+        operation_data = SWAP(
+            from_token_id="0xA0b86a33E6441c8C06DdD4D4c4c4c4c4c4c4c4c4c",
+            to_token_id="0xB1c97a44F7552d9Dd5e5e5e5e5e5e5e5e5e5e5e5e5e",
+            from_amount="1000000000000000000",
+            to_amount="995000000000000000",
+            from_amount_usd=1000.0,
+            to_amount_usd=995.0,
+        )
 
         success, data = await adapter.record_operation(
             wallet_address="0x1234567890123456789012345678901234567890",
@@ -184,7 +189,7 @@ class TestLedgerAdapter:
                 {"operation": "SWAP", "amount": "200000000000000000"},
             ]
         }
-        mock_ledger_client.get_vault_transactions.return_value = mock_transactions
+        mock_ledger_client.get_strategy_transactions.return_value = mock_transactions
 
         # Test
         success, data = await adapter.get_transaction_summary(

wayfinder_paths/adapters/pool_adapter/README.md

@@ -55,17 +55,6 @@ else:
     print(f"Error: {data}")
 ```
 
-### Get Combined Pool Reports
-
-```python
-success, data = await adapter.get_combined_pool_reports()
-if success:
-    reports = data.get("reports", [])
-    print(f"Received {len(reports)} combined reports")
-else:
-    print(f"Error: {data}")
-```
-
 ### Find High Yield Pools
 
 ```python
@@ -194,7 +183,6 @@ The adapter uses the following Wayfinder API endpoints:
 
 - `GET /api/v1/public/pools/?pool_ids=X` - Get pools by IDs
 - `GET /api/v1/public/pools/` - Get all pools
-- `GET /api/v1/public/pools/combined/` - Get combined pool reports
 - `GET /api/v1/public/pools/llama/matches/` - Get Llama matches
 - `GET /api/v1/public/pools/llama/reports/` - Get Llama reports
 
@@ -209,7 +197,7 @@ All methods return a tuple of `(success: bool, data: Any)` where:
 Run the adapter tests:
 
 ```bash
-pytest wayfinder_paths/vaults/adapters/pool_adapter/test_adapter.py -v
+pytest wayfinder_paths/adapters/pool_adapter/test_adapter.py -v
 ```
 
 ## Dependencies