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

wayfinder_paths/{vaults/adapters → adapters}/hyperlend_adapter/adapter.py

@@ -5,8 +5,15 @@ from typing import Any
 from eth_utils import to_checksum_address
 
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
-from wayfinder_paths.core.clients.HyperlendClient import HyperlendClient
+from wayfinder_paths.core.clients.HyperlendClient import (
+    AssetsView,
+    HyperlendClient,
+    LendRateHistory,
+    MarketEntry,
+    StableMarket,
+)
 from wayfinder_paths.core.clients.SimulationClient import SimulationClient
+from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
 from wayfinder_paths.core.constants.hyperlend_abi import (
     POOL_ABI,
     WRAPPED_TOKEN_GATEWAY_ABI,
@@ -43,7 +50,7 @@ class HyperlendAdapter(BaseAdapter):
         self.web3 = web3_service
         self.token_txn_service = web3_service.token_transactions
 
-        self.vault_wallet = cfg.get("vault_wallet") or {}
+        self.strategy_wallet = cfg.get("strategy_wallet") or {}
         self.pool_address = self._checksum(
             adapter_cfg.get("pool_address") or HYPERLEND_DEFAULTS["pool"]
         )
@@ -70,7 +77,7 @@ class HyperlendAdapter(BaseAdapter):
         buffer_bps: int | None = None,
         min_buffer_tokens: float | None = None,
         is_stable_symbol: bool | None = None,
-    ) -> tuple[bool, Any]:
+    ) -> tuple[bool, list[StableMarket] | str]:
         try:
             data = await self.hyperlend_client.get_stable_markets(
                 chain_id=chain_id,
@@ -85,7 +92,7 @@ class HyperlendAdapter(BaseAdapter):
 
     async def get_assets_view(
         self, chain_id: int, user_address: str
-    ) -> tuple[bool, Any]:
+    ) -> tuple[bool, AssetsView | str]:
         try:
             data = await self.hyperlend_client.get_assets_view(
                 chain_id=chain_id, user_address=user_address
@@ -96,7 +103,7 @@ class HyperlendAdapter(BaseAdapter):
 
     async def get_market_entry(
         self, chain_id: int, underlying: str
-    ) -> tuple[bool, Any]:
+    ) -> tuple[bool, MarketEntry | str]:
         try:
             data = await self.hyperlend_client.get_market_entry(chain_id, underlying)
             return True, data
@@ -108,7 +115,7 @@ class HyperlendAdapter(BaseAdapter):
         chain_id: int,
         token_address: str,
         lookback_hours: int,
-    ) -> tuple[bool, Any]:
+    ) -> tuple[bool, LendRateHistory | str]:
         try:
             data = await self.hyperlend_client.get_lend_rate_history(
                 chain_id=chain_id,
@@ -127,7 +134,7 @@ class HyperlendAdapter(BaseAdapter):
         chain_id: int,
         native: bool = False,
     ) -> tuple[bool, Any]:
-        vault = self._vault_address()
+        strategy = self._strategy_address()
         qty = int(qty)
         if qty <= 0:
             return False, "qty must be positive"
@@ -138,8 +145,8 @@ class HyperlendAdapter(BaseAdapter):
                 target=self.gateway_address,
                 abi=WRAPPED_TOKEN_GATEWAY_ABI,
                 fn_name="depositETH",
-                args=[self._gateway_first_arg(underlying_token), vault, 0],
-                from_address=vault,
+                args=[self._gateway_first_arg(underlying_token), strategy, 0],
+                from_address=strategy,
                 chain_id=chain_id,
                 value=qty,
             )
@@ -147,7 +154,7 @@ class HyperlendAdapter(BaseAdapter):
             token_addr = self._checksum(underlying_token)
             approved = await self._ensure_allowance(
                 token_address=token_addr,
-                owner=vault,
+                owner=strategy,
                 spender=self.pool_address,
                 amount=qty,
                 chain_id=chain_id,
@@ -158,8 +165,8 @@ class HyperlendAdapter(BaseAdapter):
                 target=self.pool_address,
                 abi=POOL_ABI,
                 fn_name="supply",
-                args=[token_addr, qty, vault, 0],
-                from_address=vault,
+                args=[token_addr, qty, strategy, 0],
+                from_address=strategy,
                 chain_id=chain_id,
             )
         return await self._execute(tx)
@@ -172,7 +179,7 @@ class HyperlendAdapter(BaseAdapter):
         chain_id: int,
         native: bool = False,
     ) -> tuple[bool, Any]:
-        vault = self._vault_address()
+        strategy = self._strategy_address()
         qty = int(qty)
         if qty <= 0:
             return False, "qty must be positive"
@@ -183,8 +190,8 @@ class HyperlendAdapter(BaseAdapter):
                 target=self.gateway_address,
                 abi=WRAPPED_TOKEN_GATEWAY_ABI,
                 fn_name="withdrawETH",
-                args=[self._gateway_first_arg(underlying_token), qty, vault],
-                from_address=vault,
+                args=[self._gateway_first_arg(underlying_token), qty, strategy],
+                from_address=strategy,
                 chain_id=chain_id,
             )
         else:
@@ -193,8 +200,8 @@ class HyperlendAdapter(BaseAdapter):
                 target=self.pool_address,
                 abi=POOL_ABI,
                 fn_name="withdraw",
-                args=[token_addr, qty, vault],
-                from_address=vault,
+                args=[token_addr, qty, strategy],
+                from_address=strategy,
                 chain_id=chain_id,
             )
         return await self._execute(tx)
@@ -233,14 +240,14 @@ class HyperlendAdapter(BaseAdapter):
         if self.simulation:
             return True, {"simulation": tx}
         return await self.web3.broadcast_transaction(
-            tx, wait_for_receipt=True, timeout=120
+            tx, wait_for_receipt=True, timeout=DEFAULT_TRANSACTION_TIMEOUT
         )
 
     async def _broadcast_transaction(self, tx: dict[str, Any]) -> tuple[bool, Any]:
         if getattr(settings, "DRY_RUN", False):
             return True, {"dry_run": True, "transaction": tx}
         return await self.web3.evm_transactions.broadcast_transaction(
-            tx, wait_for_receipt=True, timeout=120
+            tx, wait_for_receipt=True, timeout=DEFAULT_TRANSACTION_TIMEOUT
         )
 
     def _encode_call(
@@ -273,17 +280,17 @@ class HyperlendAdapter(BaseAdapter):
         }
         return tx
 
-    def _vault_address(self) -> str:
+    def _strategy_address(self) -> str:
         addr = None
-        if isinstance(self.vault_wallet, dict):
-            addr = self.vault_wallet.get("address") or (
-                (self.vault_wallet.get("evm") or {}).get("address")
+        if isinstance(self.strategy_wallet, dict):
+            addr = self.strategy_wallet.get("address") or (
+                (self.strategy_wallet.get("evm") or {}).get("address")
             )
-        elif isinstance(self.vault_wallet, str):
-            addr = self.vault_wallet
+        elif isinstance(self.strategy_wallet, str):
+            addr = self.strategy_wallet
         if not addr:
             raise ValueError(
-                "vault_wallet address is required for HyperLend operations"
+                "strategy_wallet address is required for HyperLend operations"
             )
         return to_checksum_address(addr)
 

wayfinder_paths/{vaults/adapters → adapters}/hyperlend_adapter/manifest.yaml

@@ -1,5 +1,5 @@
 schema_version: "0.1"
-entrypoint: "vaults.adapters.hyperlend_adapter.adapter.HyperlendAdapter"
+entrypoint: "adapters.hyperlend_adapter.adapter.HyperlendAdapter"
 capabilities:
   - "hyperlend.stable_markets.read"
   - "hyperlend.markets.query"

wayfinder_paths/{vaults/adapters → adapters}/hyperlend_adapter/test_adapter.py

@@ -2,7 +2,7 @@ from unittest.mock import AsyncMock, patch
 
 import pytest
 
-from wayfinder_paths.vaults.adapters.hyperlend_adapter.adapter import HyperlendAdapter
+from wayfinder_paths.adapters.hyperlend_adapter.adapter import HyperlendAdapter
 
 
 class TestHyperlendAdapter:
@@ -18,7 +18,7 @@ class TestHyperlendAdapter:
     def adapter(self, mock_hyperlend_client):
         """Create a HyperlendAdapter instance with mocked client for testing"""
         with patch(
-            "wayfinder_paths.vaults.adapters.hyperlend_adapter.adapter.HyperlendClient",
+            "wayfinder_paths.adapters.hyperlend_adapter.adapter.HyperlendClient",
             return_value=mock_hyperlend_client,
         ):
             return HyperlendAdapter()

wayfinder_paths/{vaults/adapters → 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
 
@@ -25,16 +25,16 @@ The LedgerClient will automatically:
 ### Initialize the Adapter
 
 ```python
-from wayfinder_paths.vaults.adapters.ledger_adapter.adapter import LedgerAdapter
+from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 
 # No configuration needed - uses LedgerClient with automatic settings
 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/{vaults/adapters → 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/{vaults/adapters → 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

@@ -0,0 +1,11 @@
+schema_version: "0.1"
+entrypoint: "adapters.ledger_adapter.adapter.LedgerAdapter"
+capabilities:
+  - "ledger.read"
+  - "ledger.write"
+  - "strategy.transactions"
+  - "strategy.deposits"
+  - "strategy.withdrawals"
+  - "strategy.operations"
+dependencies:
+  - "LedgerClient"