wayfinder-paths 0.1.19__py3-none-any.whl → 0.1.20__py3-none-any.whl

wayfinder_paths/adapters/hyperliquid_adapter/test_adapter_live.py

@@ -1,14 +1,3 @@
-"""
-Live API tests for HyperliquidAdapter.
-
-These tests hit the real Hyperliquid API to verify:
-- Spot asset ID resolution (PURR, ETH, BTC, HYPE)
-- Perp asset ID resolution
-- API connectivity
-
-Run with: pytest wayfinder_paths/adapters/hyperliquid_adapter/test_adapter_live.py -v
-"""
-
 import pytest
 
 from wayfinder_paths.adapters.hyperliquid_adapter.adapter import HyperliquidAdapter
@@ -16,16 +5,12 @@ from wayfinder_paths.adapters.hyperliquid_adapter.adapter import HyperliquidAdap
 
 @pytest.fixture
 def live_adapter():
-    """Create adapter connected to real Hyperliquid API."""
     return HyperliquidAdapter(config={})
 
 
 class TestSpotAssetIDs:
-    """Test spot asset ID resolution against live API."""
-
     @pytest.mark.asyncio
     async def test_get_spot_assets_returns_dict(self, live_adapter):
-        """Verify get_spot_assets returns a populated dict."""
         success, spot_assets = await live_adapter.get_spot_assets()
 
         assert success
@@ -34,7 +19,6 @@ class TestSpotAssetIDs:
 
     @pytest.mark.asyncio
     async def test_purr_spot_asset_id(self, live_adapter):
-        """PURR/USDC should be the first spot pair (index 0 + 10000 = 10000)."""
         success, spot_assets = await live_adapter.get_spot_assets()
 
         assert success
@@ -43,7 +27,6 @@ class TestSpotAssetIDs:
 
     @pytest.mark.asyncio
     async def test_hype_spot_asset_id(self, live_adapter):
-        """HYPE/USDC should have asset ID 10107."""
         success, spot_assets = await live_adapter.get_spot_assets()
 
         assert success
@@ -53,7 +36,6 @@ class TestSpotAssetIDs:
 
     @pytest.mark.asyncio
     async def test_eth_spot_exists(self, live_adapter):
-        """ETH/USDC spot pair should exist."""
         success, spot_assets = await live_adapter.get_spot_assets()
 
         assert success
@@ -65,7 +47,6 @@ class TestSpotAssetIDs:
 
     @pytest.mark.asyncio
     async def test_btc_spot_exists(self, live_adapter):
-        """BTC/USDC spot pair should exist."""
         success, spot_assets = await live_adapter.get_spot_assets()
 
         assert success
@@ -77,7 +58,6 @@ class TestSpotAssetIDs:
 
     @pytest.mark.asyncio
     async def test_spot_asset_ids_are_valid(self, live_adapter):
-        """All spot asset IDs should be >= 10000."""
         success, spot_assets = await live_adapter.get_spot_assets()
 
         assert success
@@ -86,7 +66,6 @@ class TestSpotAssetIDs:
 
     @pytest.mark.asyncio
     async def test_get_spot_asset_id_helper(self, live_adapter):
-        """Test synchronous helper after cache is populated."""
         # First populate cache
         success, _ = await live_adapter.get_spot_assets()
         assert success
@@ -104,11 +83,8 @@ class TestSpotAssetIDs:
 
 
 class TestPerpAssetIDs:
-    """Test perp asset ID resolution against live API."""
-
     @pytest.mark.asyncio
     async def test_coin_to_asset_mapping(self, live_adapter):
-        """Verify perp coin to asset mapping is populated."""
         coin_to_asset = live_adapter.coin_to_asset
 
         assert isinstance(coin_to_asset, dict)
@@ -116,7 +92,6 @@ class TestPerpAssetIDs:
 
     @pytest.mark.asyncio
     async def test_btc_perp_asset_id(self, live_adapter):
-        """BTC perp should be asset_id 0."""
         coin_to_asset = live_adapter.coin_to_asset
 
         assert "BTC" in coin_to_asset
@@ -124,7 +99,6 @@ class TestPerpAssetIDs:
 
     @pytest.mark.asyncio
     async def test_eth_perp_asset_id(self, live_adapter):
-        """ETH perp should be asset_id 1."""
         coin_to_asset = live_adapter.coin_to_asset
 
         assert "ETH" in coin_to_asset
@@ -132,19 +106,15 @@ class TestPerpAssetIDs:
 
     @pytest.mark.asyncio
     async def test_hype_perp_exists(self, live_adapter):
-        """HYPE perp should exist with valid asset_id."""
         coin_to_asset = live_adapter.coin_to_asset
 
         assert "HYPE" in coin_to_asset
-        assert coin_to_asset["HYPE"] < 10000  # Perp IDs are < 10000
+        assert coin_to_asset["HYPE"] < 10000
 
 
 class TestSpotMetaStructure:
-    """Test spot_meta API response structure."""
-
     @pytest.mark.asyncio
     async def test_spot_meta_has_tokens(self, live_adapter):
-        """Spot meta should have tokens array."""
         success, spot_meta = await live_adapter.get_spot_meta()
 
         assert success
@@ -154,7 +124,6 @@ class TestSpotMetaStructure:
 
     @pytest.mark.asyncio
     async def test_spot_meta_has_universe(self, live_adapter):
-        """Spot meta should have universe array with pairs."""
         success, spot_meta = await live_adapter.get_spot_meta()
 
         assert success
@@ -164,22 +133,18 @@ class TestSpotMetaStructure:
 
     @pytest.mark.asyncio
     async def test_spot_universe_pair_structure(self, live_adapter):
-        """Each spot universe entry should have tokens and index."""
         success, spot_meta = await live_adapter.get_spot_meta()
 
         assert success
-        for pair in spot_meta["universe"][:5]:  # Check first 5
+        for pair in spot_meta["universe"][:5]:
             assert "tokens" in pair, f"Missing tokens in {pair}"
             assert "index" in pair, f"Missing index in {pair}"
             assert len(pair["tokens"]) >= 2, f"Invalid tokens in {pair}"
 
 
 class TestL2BookResolution:
-    """Test that spot asset IDs work with L2 book API."""
-
     @pytest.mark.asyncio
     async def test_purr_spot_l2_book(self, live_adapter):
-        """PURR/USDC (10000) should return valid L2 book."""
         success, book = await live_adapter.get_spot_l2_book(10000)
 
         assert success
@@ -187,7 +152,6 @@ class TestL2BookResolution:
 
     @pytest.mark.asyncio
     async def test_hype_spot_l2_book(self, live_adapter):
-        """HYPE/USDC (10107) should return valid L2 book."""
         success, book = await live_adapter.get_spot_l2_book(10107)
 
         assert success
@@ -195,11 +159,8 @@ class TestL2BookResolution:
 
 
 class TestSzDecimals:
-    """Test size decimals resolution for spot assets."""
-
     @pytest.mark.asyncio
     async def test_spot_sz_decimals(self, live_adapter):
-        """Spot assets should have valid sz_decimals."""
         # HYPE spot = 10107
         decimals = live_adapter.get_sz_decimals(10107)
         assert isinstance(decimals, int)
@@ -207,7 +168,6 @@ class TestSzDecimals:
 
     @pytest.mark.asyncio
     async def test_perp_sz_decimals(self, live_adapter):
-        """Perp assets should have valid sz_decimals."""
         # BTC perp = 0
         decimals = live_adapter.get_sz_decimals(0)
         assert isinstance(decimals, int)

wayfinder_paths/adapters/hyperliquid_adapter/test_executor.py

@@ -1,5 +1,3 @@
-"""Tests for LocalHyperliquidExecutor."""
-
 from types import SimpleNamespace
 from unittest.mock import MagicMock, patch
 
@@ -7,16 +5,12 @@ import pytest
 
 
 class TestLocalHyperliquidExecutor:
-    """Tests for LocalHyperliquidExecutor."""
-
     @pytest.fixture
     def mock_info_without_asset_to_coin(self):
-        """Mock Info that only exposes coin_to_asset (no asset_to_coin)."""
         return SimpleNamespace(coin_to_asset={"HYPE": 7})
 
     @pytest.fixture
     def mock_exchange(self):
-        """Mock Exchange client."""
         mock = MagicMock()
         mock.update_leverage.return_value = {"status": "ok"}
         mock.market_open.return_value = {"status": "ok"}
@@ -26,7 +20,6 @@ class TestLocalHyperliquidExecutor:
     async def test_update_leverage_works_without_asset_to_coin(
         self, mock_info_without_asset_to_coin, mock_exchange
     ):
-        """update_leverage should map asset_id->coin via coin_to_asset inversion."""
         dummy_wallet = SimpleNamespace(address="0xabc")
 
         with patch(
@@ -66,7 +59,6 @@ class TestLocalHyperliquidExecutor:
     async def test_place_market_order_perp_works_without_asset_to_coin(
         self, mock_info_without_asset_to_coin, mock_exchange
     ):
-        """place_market_order should map asset_id->coin via coin_to_asset inversion."""
         dummy_wallet = SimpleNamespace(address="0xabc")
 
         with patch(
@@ -95,7 +87,7 @@ class TestLocalHyperliquidExecutor:
                         size=1.0,
                         address="0xabc",
                         reduce_only=False,
-                        cloid=MagicMock(),  # Avoid Cloid conversion
+                        cloid=MagicMock(),
                     )
 
                     assert resp.get("status") == "ok"

wayfinder_paths/adapters/hyperliquid_adapter/test_utils.py

@@ -1,5 +1,3 @@
-"""Tests for Hyperliquid adapter utility functions."""
-
 import pytest
 
 from wayfinder_paths.adapters.hyperliquid_adapter.utils import (
@@ -13,16 +11,12 @@ from wayfinder_paths.adapters.hyperliquid_adapter.utils import (
 
 
 class TestSpotIndexFromAssetId:
-    """Tests for spot_index_from_asset_id function."""
-
     def test_valid_spot_id(self):
-        """Valid spot asset IDs (>=10000) should return index."""
         assert spot_index_from_asset_id(10000) == 0
         assert spot_index_from_asset_id(10001) == 1
         assert spot_index_from_asset_id(10107) == 107
 
     def test_rejects_perp_id(self):
-        """Perp asset IDs (<10000) should raise ValueError."""
         with pytest.raises(ValueError, match="Expected spot asset_id >= 10000"):
             spot_index_from_asset_id(0)
 
@@ -31,14 +25,11 @@ class TestSpotIndexFromAssetId:
 
 
 class TestNormalizeL2Book:
-    """Tests for normalize_l2_book function."""
-
     def test_levels_format(self):
-        """Should handle Hyperliquid 'levels' format (nested arrays)."""
         raw = {
             "levels": [
-                [{"px": "100.5", "sz": "10"}],  # bids
-                [{"px": "101.0", "sz": "5"}],  # asks
+                [{"px": "100.5", "sz": "10"}],
+                [{"px": "101.0", "sz": "5"}],
             ],
             "midPx": "100.75",
         }
@@ -49,7 +40,6 @@ class TestNormalizeL2Book:
         assert result["midPx"] == 100.75
 
     def test_bids_asks_format(self):
-        """Should handle flat bids/asks format."""
         raw = {
             "bids": [{"px": "100.5", "sz": "10"}],
             "asks": [{"px": "101.0", "sz": "5"}],
@@ -60,7 +50,6 @@ class TestNormalizeL2Book:
         assert result["asks"] == [(101.0, 5.0)]
 
     def test_calculates_mid_from_bids_asks(self):
-        """Should calculate mid price from best bid/ask when not provided."""
         raw = {
             "levels": [
                 [{"px": "100.0", "sz": "10"}],
@@ -69,38 +58,35 @@ class TestNormalizeL2Book:
         }
         result = normalize_l2_book(raw)
 
-        assert result["midPx"] == 101.0  # (100 + 102) / 2
+        assert result["midPx"] == 101.0
 
     def test_fallback_mid(self):
-        """Should use fallback_mid when no mid can be calculated."""
         raw = {"levels": [[], []]}
         result = normalize_l2_book(raw, fallback_mid=99.0)
 
         assert result["midPx"] == 99.0
 
     def test_invalid_levels_skipped(self):
-        """Invalid level entries should be skipped."""
         raw = {
             "levels": [
                 [
-                    {"px": "100.0", "sz": "10"},  # valid
-                    {"px": "invalid", "sz": "5"},  # invalid - non-numeric
-                    {"px": "0", "sz": "5"},  # invalid - zero price
-                    {"px": "50", "sz": "0"},  # invalid - zero size
+                    {"px": "100.0", "sz": "10"},
+                    {"px": "invalid", "sz": "5"},
+                    {"px": "0", "sz": "5"},
+                    {"px": "50", "sz": "0"},
                 ],
                 [{"px": "101.0", "sz": "5"}],
             ],
         }
         result = normalize_l2_book(raw)
 
-        assert result["bids"] == [(100.0, 10.0)]  # Only valid entry
+        assert result["bids"] == [(100.0, 10.0)]
 
     def test_tuple_format_levels(self):
-        """Should handle tuple/list format levels."""
         raw = {
             "levels": [
-                [[100.0, 10.0]],  # bids as tuples
-                [[101.0, 5.0]],  # asks as tuples
+                [[100.0, 10.0]],
+                [[101.0, 5.0]],
             ],
         }
         result = normalize_l2_book(raw)
@@ -110,13 +96,10 @@ class TestNormalizeL2Book:
 
 
 class TestUsdDepthInBand:
-    """Tests for usd_depth_in_band function."""
-
     def test_buy_side(self):
-        """Buy side should measure ask depth within band."""
         book = {
-            "bids": [(99.0, 10.0), (98.0, 20.0)],  # $990 + $1960 = $2950
-            "asks": [(101.0, 5.0), (102.0, 10.0)],  # $505 + $1020 = $1525
+            "bids": [(99.0, 10.0), (98.0, 20.0)],
+            "asks": [(101.0, 5.0), (102.0, 10.0)],
             "midPx": 100.0,
         }
         # 100 bps = 1% band, so hi = 101.0
@@ -127,7 +110,6 @@ class TestUsdDepthInBand:
         assert depth == 505.0
 
     def test_sell_side(self):
-        """Sell side should measure bid depth within band."""
         book = {
             "bids": [(99.0, 10.0), (98.0, 20.0)],
             "asks": [(101.0, 5.0), (102.0, 10.0)],
@@ -141,7 +123,6 @@ class TestUsdDepthInBand:
         assert depth == 990.0
 
     def test_zero_mid(self):
-        """Zero mid price should return zero depth."""
         book = {"bids": [(99.0, 10.0)], "asks": [(101.0, 5.0)], "midPx": 0.0}
         depth, mid = usd_depth_in_band(book, band_bps=100, side="buy")
 
@@ -150,10 +131,7 @@ class TestUsdDepthInBand:
 
 
 class TestSzDecimalsForAsset:
-    """Tests for sz_decimals_for_asset function."""
-
     def test_known_asset(self):
-        """Should return decimals for known asset."""
         asset_to_sz = {0: 4, 1: 3, 10000: 6}
 
         assert sz_decimals_for_asset(asset_to_sz, 0) == 4
@@ -161,7 +139,6 @@ class TestSzDecimalsForAsset:
         assert sz_decimals_for_asset(asset_to_sz, 10000) == 6
 
     def test_unknown_raises(self):
-        """Unknown asset should raise ValueError."""
         asset_to_sz = {0: 4}
 
         with pytest.raises(ValueError, match="Unknown asset_id 999"):
@@ -169,10 +146,7 @@ class TestSzDecimalsForAsset:
 
 
 class TestSizeStep:
-    """Tests for size_step function."""
-
     def test_size_step_calculation(self):
-        """Size step should be 10^(-decimals)."""
         from decimal import Decimal
 
         asset_to_sz = {0: 4, 1: 2}
@@ -182,26 +156,21 @@ class TestSizeStep:
 
 
 class TestRoundSizeForAsset:
-    """Tests for round_size_for_asset function."""
-
     def test_floors_correctly(self):
-        """Should floor to size step."""
-        asset_to_sz = {0: 4}  # Step = 0.0001
+        asset_to_sz = {0: 4}
 
         # 1.23456789 should floor to 1.2345
         result = round_size_for_asset(asset_to_sz, 0, 1.23456789)
         assert result == 1.2345
 
     def test_zero_returns_zero(self):
-        """Zero or negative size returns 0."""
         asset_to_sz = {0: 4}
 
         assert round_size_for_asset(asset_to_sz, 0, 0.0) == 0.0
         assert round_size_for_asset(asset_to_sz, 0, -1.0) == 0.0
 
     def test_ensure_min_step(self):
-        """With ensure_min_step=True, tiny values become one step."""
-        asset_to_sz = {0: 4}  # Step = 0.0001
+        asset_to_sz = {0: 4}
 
         # Without ensure_min_step: 0.00001 floors to 0
         result = round_size_for_asset(asset_to_sz, 0, 0.00001, ensure_min_step=False)
@@ -212,8 +181,7 @@ class TestRoundSizeForAsset:
         assert result == 0.0001
 
     def test_preserves_precision(self):
-        """Should not introduce float precision errors."""
-        asset_to_sz = {0: 2}  # Step = 0.01
+        asset_to_sz = {0: 2}
 
         # 0.1 + 0.2 = 0.30000000000000004 in float
         result = round_size_for_asset(asset_to_sz, 0, 0.1 + 0.2)

wayfinder_paths/adapters/hyperliquid_adapter/utils.py

@@ -6,7 +6,6 @@ from typing import Any
 
 
 def spot_index_from_asset_id(spot_asset_id: int) -> int:
-    """Convert Hyperliquid spot asset_id (>=10000) to spot index."""
     if spot_asset_id < 10000:
         raise ValueError(f"Expected spot asset_id >= 10000, got {spot_asset_id}")
     return int(spot_asset_id) - 10000
@@ -17,8 +16,6 @@ def normalize_l2_book(
     *,
     fallback_mid: float | None = None,
 ) -> dict[str, Any]:
-    """Normalize Hyperliquid L2 into bids/asks lists with floats."""
-
     def coerce_levels(levels: Any) -> list[tuple[float, float]]:
         normalized: list[tuple[float, float]] = []
         if not isinstance(levels, list):
@@ -74,7 +71,6 @@ def normalize_l2_book(
 def usd_depth_in_band(
     book: dict[str, Any], band_bps: int, side: str
 ) -> tuple[float, float]:
-    """Return USD depth inside a +/- band (bps) around mid price for a side."""
     bids = book.get("bids") or []
     asks = book.get("asks") or []
     mid = float(book.get("midPx") or 0.0)
@@ -102,14 +98,12 @@ def usd_depth_in_band(
 def sz_decimals_for_asset(
     asset_to_sz_decimals: Mapping[int, int], asset_id: int
 ) -> int:
-    """Return Hyperliquid size decimals (szDecimals) for an asset_id."""
     if asset_id not in asset_to_sz_decimals:
         raise ValueError(f"Unknown asset_id {asset_id}: missing szDecimals")
     return int(asset_to_sz_decimals[asset_id])
 
 
 def size_step(asset_to_sz_decimals: Mapping[int, int], asset_id: int) -> Decimal:
-    """Return the size increment step for an asset_id."""
     return Decimal(10) ** (-sz_decimals_for_asset(asset_to_sz_decimals, asset_id))
 
 
@@ -120,7 +114,6 @@ def round_size_for_asset(
     *,
     ensure_min_step: bool = False,
 ) -> float:
-    """Floor to size step using Decimal to avoid float issues."""
     size_d = size if isinstance(size, Decimal) else Decimal(str(size))
     if size_d <= 0:
         return 0.0

wayfinder_paths/adapters/ledger_adapter/README.md

@@ -1,145 +1,125 @@
 # Ledger Adapter
 
-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.
+Adapter for strategy transaction recording and bookkeeping.
 
-## Capabilities
+- **Type**: `LEDGER`
+- **Module**: `wayfinder_paths.adapters.ledger_adapter.adapter.LedgerAdapter`
 
-- `ledger.read`: Read strategy transaction data and net deposits
-- `ledger.write`: Record deposits, withdrawals, and operations
-- `strategy.transactions`: Access strategy transaction history
-- `strategy.deposits`: Record deposit transactions
-- `strategy.withdrawals`: Record withdrawal transactions
-- `strategy.operations`: Record strategy operations (swaps, rebalances, etc.)
+## Overview
 
-## Configuration
-
-The adapter uses the LedgerClient which automatically handles authentication and API configuration through the Wayfinder settings. No additional configuration is required.
-
-The LedgerClient will automatically:
-- Use the WAYFINDER_API_URL from settings
-- Handle authentication via config.json
-- Manage token refresh and retry logic
+The LedgerAdapter provides:
+- Transaction history tracking
+- Net deposit calculations
+- Deposit/withdrawal recording
+- Strategy operation logging
 
 ## Usage
 
-### Initialize the Adapter
-
 ```python
 from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 
-# No configuration needed - uses LedgerClient with automatic settings
 adapter = LedgerAdapter()
 ```
 
-### Get Strategy Transaction History
+## Methods
+
+### get_strategy_transactions
+
+Get transaction history for a strategy wallet.
 
 ```python
 success, data = await adapter.get_strategy_transactions(
-    wallet_address="0x1234567890123456789012345678901234567890",
+    wallet_address="0x...",
     limit=10,
-    offset=0
+    offset=0,
 )
 if success:
     transactions = data.get("transactions", [])
-    print(f"Found {len(transactions)} transactions")
-else:
-    print(f"Error: {data}")
 ```
 
-### Get Net Deposit Amount
+### get_strategy_net_deposit
+
+Get the net deposit amount for a strategy.
 
 ```python
 success, data = await adapter.get_strategy_net_deposit(
-    wallet_address="0x1234567890123456789012345678901234567890"
+    wallet_address="0x..."
 )
 if success:
     net_deposit = data.get("net_deposit", 0)
-    print(f"Net deposit: {net_deposit} USDC")
-else:
-    print(f"Error: {data}")
 ```
 
-### Record a Deposit
+### record_deposit
+
+Record a deposit transaction.
 
 ```python
 success, data = await adapter.record_deposit(
-    wallet_address="0x1234567890123456789012345678901234567890",
+    wallet_address="0x...",
     chain_id=8453,
-    token_address="0xA0b86a33E6441c8C06DdD4D4c4c4c4c4c4c4c4c4c",
-    token_amount="1000000000000000000",
+    token_address="0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    token_amount="1000000000",
     usd_value="1000.00",
-    strategy_name="StablecoinYieldStrategy"
+    strategy_name="my_strategy",
 )
-if success:
-    print(f"Deposit recorded: {data.get('transaction_id')}")
-else:
-    print(f"Error: {data}")
 ```
 
-### Record a Withdrawal
+### record_withdrawal
+
+Record a withdrawal transaction.
 
 ```python
 success, data = await adapter.record_withdrawal(
-    wallet_address="0x1234567890123456789012345678901234567890",
+    wallet_address="0x...",
     chain_id=8453,
-    token_address="0xA0b86a33E6441c8C06DdD4D4c4c4c4c4c4c4c4c4c",
-    token_amount="500000000000000000",
+    token_address="0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    token_amount="500000000",
     usd_value="500.00",
-    strategy_name="StablecoinYieldStrategy"
+    strategy_name="my_strategy",
 )
-if success:
-    print(f"Withdrawal recorded: {data.get('transaction_id')}")
-else:
-    print(f"Error: {data}")
 ```
 
-### Record an Operation
+### record_operation
+
+Record a strategy operation (swap, rebalance, etc.).
 
 ```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_token_id="0x...",
+    to_token_id="0x...",
+    from_amount="1000000000",
+    to_amount="995000000",
     from_amount_usd=1000.0,
     to_amount_usd=995.0,
 )
 
-success, op = await adapter.record_operation(
-    wallet_address=strategy_address,
+success, data = await adapter.record_operation(
+    wallet_address="0x...",
     operation_data=operation,
     usd_value="1000.00",
-    strategy_name="StablecoinYieldStrategy",
+    strategy_name="my_strategy",
 )
-
 ```
 
-### Latest Transactions and Summaries
+### record_strategy_snapshot
+
+Record a strategy status snapshot.
 
 ```python
-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')}")
+success, data = await adapter.record_strategy_snapshot(
+    wallet_address="0x...",
+    strategy_status={"portfolio_value": 1000.0, ...},
+)
 ```
 
-## Error Handling
+## Dependencies
 
-All methods return a tuple of `(success: bool, data: Any)` where:
-- `success` is `True` if the operation succeeded
-- `data` contains the response data on success or error message on failure
+- `LedgerClient` - Low-level API client
 
 ## Testing
 
-Run the adapter tests:
-
 ```bash
-pytest wayfinder_paths/adapters/ledger_adapter/test_adapter.py -v
+poetry run pytest wayfinder_paths/adapters/ledger_adapter/ -v
 ```
-
-## Dependencies
-
-- `LedgerClient` - Low-level API client for ledger operations
-- `BaseAdapter` - Base adapter class with common functionality

wayfinder_paths/adapters/ledger_adapter/__init__.py

@@ -1,7 +1,3 @@
-"""
-Ledger Adapter Package
-"""
-
 from .adapter import LedgerAdapter
 
 __all__ = ["LedgerAdapter"]