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

wayfinder_paths/strategies/stablecoin_yield_strategy/README.md

@@ -1,88 +1,93 @@
 # Stablecoin Yield Strategy
 
-- Entrypoint: `strategies.stablecoin_yield_strategy.strategy.StablecoinYieldStrategy`
-- Examples: `examples.json`
-- Tests: `test_strategy.py`
+Automated USDC yield optimization on Base chain.
 
-## What it does
+- **Module**: `wayfinder_paths.strategies.stablecoin_yield_strategy.strategy.StablecoinYieldStrategy`
+- **Chain**: Base (8453)
+- **Token**: USDC
 
-Actively manages Base USDC deposits. Deposits pull USDC (plus an ETH gas buffer) from the main wallet into the strategy wallet, then the strategy searches Base-native pools for the best USD-denominated APY. Updates monitor DeFi Llama feeds and Wayfinder pool analytics, respecting a rotation cooldown and minimum APY improvement before rebalancing via the BRAP router. Withdrawals unwind the current position, sweep residual tokens back into USDC, and return funds to the main wallet.
+## Overview
 
-## On-chain policy
+This strategy actively manages USDC deposits by:
+1. Transferring USDC (plus ETH gas buffer) from main wallet to strategy wallet
+2. Searching Base-native pools for the best USD-denominated APY
+3. Monitoring DeFi Llama feeds and Wayfinder pool analytics
+4. Rebalancing to higher-yield pools when APY improvements exceed thresholds
+5. Respecting rotation cooldowns to avoid excessive churn
 
-Transactions are scoped to the strategy wallet and Enso Router approval/swap calls:
+## Key Parameters
 
-```
-(wallet.id == 'FORMAT_WALLET_ID') && ((eth.tx.data[0..10] == '0x095ea7b3' && eth.tx.data[34..74] == 'f75584ef6673ad213a685a1b58cc0330b8ea22cf') || (eth.tx.to == '0xF75584eF6673aD213a685a1B58Cc0330B8eA22Cf'))
-```
-
-## Key parameters (from `strategy.py`)
+| Parameter | Value | Description |
+|-----------|-------|-------------|
+| `MIN_AMOUNT_USDC` | 2 | Minimum deposit amount |
+| `MIN_TVL` | 1,000,000 | Minimum pool TVL |
+| `ROTATION_MIN_INTERVAL` | 14 days | Cooldown between rotations |
+| `DUST_APY` | 0.01 (1%) | APY threshold below which pools are ignored |
+| `SEARCH_DEPTH` | 10 | Number of pools to examine |
+| `MIN_GAS` | 0.001 ETH | Minimum gas buffer |
+| `GAS_MAXIMUM` | 0.02 ETH | Maximum gas per deposit |
 
-- `MIN_AMOUNT_USDC = 2` → deposits smaller than 2 USDC are rejected.
-- `MIN_TVL = 1_000_000` → pools below $1M TVL are ignored.
-- `ROTATION_MIN_INTERVAL = 14 days` → once rotated, the strategy waits ~2 weeks unless the new candidate dramatically outperforms.
-- `DUST_APY = 0.01` (1%) → pools below this APY are treated as dust.
-- `SEARCH_DEPTH = 10` → how many pools to examine when selecting candidates.
-- `MIN_GAS = 0.001` and `GAS_MAXIMUM = 0.02` Base ETH → minimum buffer required in the strategy wallet plus the upper bound accepted per deposit.
+## Adapters Used
 
-## Adapters used
-
-- `BalanceAdapter` for wallet/pool balances and orchestrating transfers between the main and strategy wallets (with ledger recording).
-- `PoolAdapter` for pool metadata, llama reports, and yield analytics.
-- `BRAPAdapter` to source swap quotes and execute rotations.
-- `TokenAdapter` for metadata (gas token, USDC info).
-- `LedgerAdapter` for net-deposit tracking and cooldown enforcement.
+- **BalanceAdapter**: Wallet/pool balances, cross-wallet transfers
+- **PoolAdapter**: Pool metadata, yield analytics
+- **BRAPAdapter**: Swap quotes and execution
+- **TokenAdapter**: Token metadata (gas token, USDC info)
+- **LedgerAdapter**: Net deposit tracking, cooldown enforcement
 
 ## Actions
 
 ### Deposit
 
-- Validates `main_token_amount` ≥ `MIN_AMOUNT_USDC` and `gas_token_amount` ≤ `GAS_MAXIMUM`.
-- Confirms the main wallet holds enough USDC and Base ETH.
-- Moves Base ETH into the strategy wallet (when requested or when the strategy needs a top-up), then transfers the requested USDC amount via `BalanceAdapter.move_from_main_wallet_to_strategy_wallet`.
-- Hydrates the on-chain position snapshot so future updates know which pool is active.
+```bash
+poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy \
+    --action deposit --main-token-amount 60 --gas-token-amount 0.001 --config config.json
+```
+
+- Validates `main_token_amount >= MIN_AMOUNT_USDC`
+- Validates `gas_token_amount <= GAS_MAXIMUM`
+- Transfers ETH and USDC to strategy wallet
+- Initializes position tracking
 
 ### Update
 
-- Fetches the latest strategy balances, idle assets, and current target pool.
-- Runs `_find_best_pool()` which uses `PoolAdapter` and DeFi Llama data to score up to `SEARCH_DEPTH` pools that satisfy the APY/TVL filters.
-- Checks `LedgerAdapter.get_strategy_latest_transactions()` to enforce the rotation cooldown, unless the new candidate clears the APY-improvement threshold.
-- If rotation is approved, requests a BRAP quote, ensures the strategy has enough gas, executes the swap via `BRAPAdapter.swap_from_quote`, and sweeps any idle balances back into the target token.
-- Records informative status messages when no better pool exists or when cooldown blocks a move.
+```bash
+poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy \
+    --action update --config config.json
+```
+
+- Fetches current balances and active pool
+- Runs `_find_best_pool()` to score candidate pools
+- Checks rotation cooldown via LedgerAdapter
+- Executes rotation if APY improvement threshold met
+- Sweeps idle balances into target token
 
 ### Status
 
-`_status()` reports:
+```bash
+poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy \
+    --action status --config config.json
+```
 
-- `portfolio_value`: refreshed pool balance (in base units) converted to float.
-- `net_deposit`: data pulled from `LedgerAdapter.get_strategy_net_deposit`.
-- `strategy_status`: dictionary exposing the active pool, APY estimates, and wallet balances.
+Returns:
+- `portfolio_value`: Current pool balance
+- `net_deposit`: From LedgerAdapter
+- `strategy_status`: Active pool, APY, wallet balances
 
 ### Withdraw
 
-- Requires a prior deposit (the strategy tracks `self.DEPOSIT_USDC`).
-- Reads the pool balance via `BalanceAdapter.get_balance` (with pool address and chain_id), unwinds via BRAP swaps back to USDC, and moves USDC from the strategy wallet to the main wallet via `BalanceAdapter.move_from_strategy_wallet_to_main_wallet`.
-- Updates the ledger and clears cached pool state.
-
-## Running locally
-
 ```bash
-# Install dependencies
-poetry install
-
-# Generate main wallet (writes config.json)
-# Creates a main wallet (or use 'just create-strategy' which auto-creates wallets)
-poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
+poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy \
+    --action withdraw --config config.json
+```
 
-# Copy the example config and set credentials if needed
-cp wayfinder_paths/config.example.json config.json
+- Unwinds current position via BRAP swaps
+- Converts all holdings back to USDC
+- Transfers USDC to main wallet
+- Clears cached pool state
 
-# Smoke test the strategy
-poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy --action status --config $(pwd)/config.json
+## Testing
 
-# Perform a funded deposit/update cycle
-poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy --action deposit --main-token-amount 60 --gas-token-amount 0.001 --config $(pwd)/config.json
-poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy --action update --config $(pwd)/config.json
+```bash
+poetry run pytest wayfinder_paths/strategies/stablecoin_yield_strategy/ -v
 ```
-
-Wallet addresses are auto-populated from `config.json` when you run `wayfinder_paths/scripts/make_wallets.py`. Set `NETWORK=testnet` in `config.json` to dry-run operations against mocked services.

wayfinder_paths/strategies/stablecoin_yield_strategy/strategy.py

@@ -32,12 +32,12 @@ class StablecoinYieldStrategy(Strategy):
     MINIMUM_DAYS_UNTIL_PROFIT = 7
     MIN_TVL = 1_000_000
     DUST_APY = 0.01
-    MIN_GAS = 10e-4  # ethereum float
+    MIN_GAS = 10e-4
     SEARCH_DEPTH = 10
     SUPPORTED_NETWORK_CODES = {"base"}
     ROTATION_MIN_INTERVAL = timedelta(days=14)
     MINIMUM_APY_IMPROVEMENT = 0.01
-    GAS_MAXIMUM = 10e-4  # ethereum float
+    GAS_MAXIMUM = 10e-4
     GAS_SAFETY_FRACTION = 1 / 3
 
     INFO = StratDescriptor(
@@ -226,7 +226,6 @@ class StablecoinYieldStrategy(Strategy):
             pass
 
     def _get_strategy_wallet_address(self) -> str:
-        """Get strategy wallet address with validation."""
         strategy_wallet = self.config.get("strategy_wallet")
         if not strategy_wallet or not isinstance(strategy_wallet, dict):
             raise ValueError("strategy_wallet not configured in strategy config")
@@ -236,7 +235,6 @@ class StablecoinYieldStrategy(Strategy):
         return str(address)
 
     def _get_main_wallet_address(self) -> str:
-        """Get main wallet address with validation."""
         main_wallet = self.config.get("main_wallet")
         if not main_wallet or not isinstance(main_wallet, dict):
             raise ValueError("main_wallet not configured in strategy config")
@@ -246,21 +244,18 @@ class StablecoinYieldStrategy(Strategy):
         return str(address)
 
     def _track_token(self, token_id: str, balance_wei: int = 0):
-        """Track a token that the strategy holds or might hold."""
         if token_id:
             self.tracked_token_ids.add(token_id)
             if balance_wei > 0:
                 self.tracked_balances[token_id] = balance_wei
 
     def _update_balance(self, token_id: str, balance_wei: int):
-        """Update the tracked balance for a token."""
         if token_id:
             self.tracked_balances[token_id] = balance_wei
             if balance_wei > 0:
                 self.tracked_token_ids.add(token_id)
 
     async def _refresh_tracked_balances(self):
-        """Refresh balances for all tracked tokens from on-chain data."""
         strategy_address = self._get_strategy_wallet_address()
         for token_id in self.tracked_token_ids:
             try:
@@ -277,7 +272,6 @@ class StablecoinYieldStrategy(Strategy):
                 self.tracked_balances[token_id] = 0
 
     def _get_non_zero_tracked_tokens(self) -> list[tuple[str, int]]:
-        """Get list of (token_id, balance_wei) for tokens with non-zero balances."""
         return [
             (token_id, balance)
             for token_id, balance in self.tracked_balances.items()
@@ -291,7 +285,6 @@ class StablecoinYieldStrategy(Strategy):
         await super().setup()
         self.current_combined_apy_pct = 0.0
 
-        # Get strategy net deposit
         try:
             logger.info("Fetching strategy net deposit from ledger")
             strategy_address = self._get_strategy_wallet_address()
@@ -308,7 +301,6 @@ class StablecoinYieldStrategy(Strategy):
             logger.error(f"Failed to fetch strategy net deposit: {e}")
             self.DEPOSIT_USDC = 0
 
-        # Get USDC token info
         try:
             logger.info("Fetching USDC token information")
             success, self.usdc_token_info = await self.token_adapter.get_token(
@@ -340,11 +332,10 @@ class StablecoinYieldStrategy(Strategy):
 
         self.current_pool_data = None
 
-        chain_code = "base"  # Default to base
+        chain_code = "base"
         if self.current_pool and self.current_pool.get("chain"):
             chain_code = self.current_pool.get("chain").get("code", "base")
 
-        # Get gas token info
         try:
             logger.info(f"Fetching gas token for chain: {chain_code}")
             success, gas_token_data = await self.token_adapter.get_gas_token(chain_code)
@@ -368,7 +359,6 @@ class StablecoinYieldStrategy(Strategy):
             self.current_pool_balance = 0
             return
 
-        # Get strategy transactions to determine current position and build tracked token set
         try:
             logger.info("Fetching strategy transaction history to build state")
             success, txns_data = await self.ledger_adapter.get_strategy_transactions(
@@ -382,7 +372,6 @@ class StablecoinYieldStrategy(Strategy):
                 ]
                 logger.info(f"Found {len(txns)} non-deposit transactions")
 
-                # Build tracked token set from transaction history
                 for txn in txns:
                     op_data = txn.get("data", {}).get("op_data", {})
                     # Track any token that was swapped TO
@@ -585,7 +574,6 @@ class StablecoinYieldStrategy(Strategy):
         return total_usd
 
     async def _infer_active_pool_from_tracked_tokens(self):
-        """Infer the active pool from tracked tokens with non-zero balances."""
         try:
             # Refresh balances for tracked tokens
             await self._refresh_tracked_balances()
@@ -613,12 +601,10 @@ class StablecoinYieldStrategy(Strategy):
             if not best_token_id:
                 return None
 
-            # Fetch token info
             success, token = await self.token_adapter.get_token(best_token_id)
             if not success:
                 return None
 
-            # Get fresh on-chain balance
             strategy_address = self._get_strategy_wallet_address()
             try:
                 success, onchain_balance = await self.balance_adapter.get_balance(
@@ -640,11 +626,9 @@ class StablecoinYieldStrategy(Strategy):
             return None
 
     def _is_gas_balance_entry(self, balance: dict[str, Any]) -> bool:
-        """Check if a balance entry represents a gas token."""
         if not self.gas_token:
             return False
 
-        # Check by token ID
         token_id = balance.get("token_id")
         if (
             isinstance(token_id, str)
@@ -652,13 +636,11 @@ class StablecoinYieldStrategy(Strategy):
         ):
             return True
 
-        # Check by token address and network
         token_address = balance.get("tokenAddress")
         if isinstance(token_address, str):
             if token_address.lower() == self.gas_token.get("address", "").lower():
                 return True
 
-            # Check address + network combination
             network = (balance.get("network") or "").lower()
             chain_code = self.current_pool.get("chain", {}).get("code", "").lower()
             if (
@@ -698,7 +680,6 @@ class StablecoinYieldStrategy(Strategy):
                 f"Current pool set to: {token_info.get('symbol')} on {token_info.get('chain', {}).get('name')}"
             )
 
-            # Check main wallet USDC balance if depositing main token
             if main_token_amount > 0:
                 logger.info("Checking main wallet USDC balance")
                 (
@@ -735,7 +716,6 @@ class StablecoinYieldStrategy(Strategy):
                         f"Minimum deposit is {self.MIN_AMOUNT_USDC} USDC on Base. Received: {main_token_amount}",
                     )
 
-            # Check gas token amount if provided
             if gas_token_amount > 0:
                 if gas_token_amount > self.GAS_MAXIMUM:
                     return (
@@ -766,7 +746,6 @@ class StablecoinYieldStrategy(Strategy):
                         f"Main wallet {gas_symbol} balance is less than the deposit amount: {main_gas_native} < {gas_token_amount}",
                     )
 
-            # Check gas balances for minimum requirement (only if depositing main token)
             if main_token_amount > 0:
                 logger.info("Checking gas token balances for operations")
                 gas_decimals = self.gas_token.get("decimals")
@@ -838,7 +817,6 @@ class StablecoinYieldStrategy(Strategy):
                     return (False, f"USDC transfer to strategy failed: {msg}")
                 logger.info("USDC transfer completed successfully")
 
-                # Update tracked state
                 self._track_token(self.usdc_token_info.get("token_id"))
                 self._update_balance(
                     self.usdc_token_info.get("token_id"),
@@ -847,7 +825,6 @@ class StablecoinYieldStrategy(Strategy):
 
             # Transfer gas if provided or if strategy needs top-up
             if gas_token_amount > 0:
-                # Get gas symbol if not already defined
                 if main_token_amount == 0:
                     gas_symbol = self.gas_token.get("symbol")
 
@@ -902,7 +879,6 @@ class StablecoinYieldStrategy(Strategy):
                 False,
                 "Nothing to withdraw from strategy, wallet should be empty already. If not, an error has happened please manually remove funds",
             )
-        # Get current pool balance
         logger.info("Fetching current pool balance")
         try:
             (
@@ -918,7 +894,6 @@ class StablecoinYieldStrategy(Strategy):
             logger.error(f"Failed to fetch pool balance: {e}")
             self.current_pool_balance = 0
 
-        # Check if we need to swap out of current position
         if (
             self.current_pool.get("token_id") != self.usdc_token_info.get("token_id")
             and self.current_pool_balance
@@ -951,7 +926,7 @@ class StablecoinYieldStrategy(Strategy):
                         break
                 except Exception as e:
                     logger.warning(f"Quote attempt {attempt + 1} failed: {e}")
-                    if attempt == 3:  # Last attempt
+                    if attempt == 3:
                         logger.error("All quote attempts failed")
 
             best_quote = quotes.get("best_quote") if isinstance(quotes, dict) else None
@@ -1006,7 +981,6 @@ class StablecoinYieldStrategy(Strategy):
 
         await self._sweep_wallet(self.usdc_token_info)
 
-        # Get final USDC balance in strategy wallet
         status, raw_balance = await self.balance_adapter.get_balance(
             query=self.usdc_token_info.get("token_id"),
             wallet_address=self._get_strategy_wallet_address(),
@@ -1017,7 +991,6 @@ class StablecoinYieldStrategy(Strategy):
                 "decimals"
             )
 
-        # Get gas balance in strategy wallet
         gas_amount = 0.0
         if self.gas_token:
             status, raw_gas = await self.balance_adapter.get_balance(
@@ -1047,7 +1020,6 @@ class StablecoinYieldStrategy(Strategy):
         )
 
     async def exit(self, **kwargs) -> StatusTuple:
-        """Transfer funds from strategy wallet to main wallet."""
         logger.info("EXIT: Transferring remaining funds to main wallet")
 
         strategy_address = self._get_strategy_wallet_address()
@@ -1299,7 +1271,6 @@ class StablecoinYieldStrategy(Strategy):
             pass
 
     async def _sweep_wallet(self, target_token):
-        """Sweep all tracked non-target tokens into the target token."""
         # Refresh tracked balances
         await self._refresh_tracked_balances()
 
@@ -1322,7 +1293,6 @@ class StablecoinYieldStrategy(Strategy):
             if token_id == target_token_id:
                 continue
 
-            # Get fresh balance to ensure accuracy
             try:
                 success, fresh_balance = await self.balance_adapter.get_balance(
                     query=token_id,
@@ -1351,7 +1321,6 @@ class StablecoinYieldStrategy(Strategy):
                     strategy_name=self.name,
                 )
                 if success:
-                    # Update tracked state: source token now has 0 balance
                     self._update_balance(token_id, 0)
                     logger.info(f"Successfully swept {token_id} to {target_token_id}")
                 else:
@@ -1454,7 +1423,6 @@ class StablecoinYieldStrategy(Strategy):
         )
 
     async def _get_non_gas_balances(self) -> list[dict[str, Any]]:
-        """Get non-gas balances from tracked tokens."""
         # Refresh tracked balances
         await self._refresh_tracked_balances()
 
@@ -1470,7 +1438,6 @@ class StablecoinYieldStrategy(Strategy):
             if balance_wei <= 0:
                 continue
 
-            # Fetch token info to get address and chain
             try:
                 success, token_info = await self.token_adapter.get_token(token_id)
                 if not success or not token_info:
@@ -1634,7 +1601,6 @@ class StablecoinYieldStrategy(Strategy):
         return float(gas_price) * float(amount) / (10 ** token.get("decimals"))
 
     async def _status(self) -> StatusDict:
-        # Get ETH gas balance
         gas_success, gas_balance_wei = await self.balance_adapter.get_balance(
             query=self.gas_token.get("token_id"),
             wallet_address=self._get_strategy_wallet_address(),
@@ -1663,7 +1629,6 @@ class StablecoinYieldStrategy(Strategy):
         # Refresh tracked balances
         await self._refresh_tracked_balances()
 
-        # Calculate total value from tracked non-gas balances
         total_value = 0.0
         gas_token_id = self.gas_token.get("token_id") if self.gas_token else None
 
@@ -1674,7 +1639,6 @@ class StablecoinYieldStrategy(Strategy):
                 continue
 
             try:
-                # Get token price to calculate USD value
                 success, price_data = await self.token_adapter.get_token_price(token_id)
                 if not success:
                     continue
@@ -1728,7 +1692,6 @@ class StablecoinYieldStrategy(Strategy):
         return [f"({wallet_id}) && (({approve_enso}) || ({swap_enso})) "]
 
     async def partial_liquidate(self, usd_value: float) -> StatusTuple:
-        """Liquidate strategy assets to reach target USD value in USDC."""
         # Refresh tracked balances
         await self._refresh_tracked_balances()
 
@@ -1736,7 +1699,6 @@ class StablecoinYieldStrategy(Strategy):
         usdc_decimals = self.usdc_token_info.get("decimals")
         gas_token_id = self.gas_token.get("token_id") if self.gas_token else None
 
-        # Check current USDC balance
         available_usdc_wei = self.tracked_balances.get(usdc_token_id, 0)
         available_usdc_usd = float(available_usdc_wei) / (10**usdc_decimals)
 
@@ -1757,7 +1719,6 @@ class StablecoinYieldStrategy(Strategy):
             if balance_wei <= 0:
                 continue
 
-            # Get token info and price
             try:
                 success, token_info = await self.token_adapter.get_token(token_id)
                 if not success:
@@ -1789,7 +1750,6 @@ class StablecoinYieldStrategy(Strategy):
                     if success:
                         swapped_usd = (amount_to_swap / (10**decimals)) * price
                         available_usdc_usd += swapped_usd
-                        # Update tracked state
                         self._update_balance(token_id, balance_wei - amount_to_swap)
                     else:
                         logger.warning(f"Failed to liquidate {token_id}: {msg}")

wayfinder_paths/strategies/stablecoin_yield_strategy/test_strategy.py

@@ -15,7 +15,6 @@ elif sys.path.index(_wayfinder_path_str) > 0:
 
 import pytest  # noqa: E402
 
-# Import test utilities
 try:
     from tests.test_utils import get_canonical_examples, load_strategy_examples
 except ImportError:
@@ -36,7 +35,6 @@ from wayfinder_paths.strategies.stablecoin_yield_strategy.strategy import (  # n
 
 @pytest.fixture
 def strategy():
-    """Create a strategy instance for testing with minimal config."""
     mock_config = {
         "main_wallet": {"address": "0x1234567890123456789012345678901234567890"},
         "strategy_wallet": {"address": "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"},
@@ -260,7 +258,6 @@ def strategy():
 @pytest.mark.asyncio
 @pytest.mark.smoke
 async def test_smoke(strategy):
-    """REQUIRED: Basic smoke test - verifies strategy lifecycle."""
     examples = load_strategy_examples(Path(__file__))
     smoke_data = examples["smoke"]
 
@@ -282,11 +279,6 @@ async def test_smoke(strategy):
 
 @pytest.mark.asyncio
 async def test_canonical_usage(strategy):
-    """REQUIRED: Test canonical usage examples from examples.json (minimum).
-
-    Canonical usage = all positive usage examples (excluding error cases).
-    This is the MINIMUM requirement - feel free to add more test cases here.
-    """
     examples = load_strategy_examples(Path(__file__))
     canonical = get_canonical_examples(examples)
 
@@ -309,7 +301,6 @@ async def test_canonical_usage(strategy):
 
 @pytest.mark.asyncio
 async def test_error_cases(strategy):
-    """OPTIONAL: Test error scenarios from examples.json."""
     examples = load_strategy_examples(Path(__file__))
 
     for example_name, example_data in examples.items():
@@ -341,7 +332,6 @@ async def test_error_cases(strategy):
 
 @pytest.mark.asyncio
 async def test_token_tracking_initialization(strategy):
-    """Test that tracked_token_ids and tracked_balances are initialized."""
     assert hasattr(strategy, "tracked_token_ids")
     assert hasattr(strategy, "tracked_balances")
     assert isinstance(strategy.tracked_token_ids, set)
@@ -350,7 +340,6 @@ async def test_token_tracking_initialization(strategy):
 
 @pytest.mark.asyncio
 async def test_track_token(strategy):
-    """Test that _track_token adds tokens to tracked state."""
     test_token_id = "test-token-base"
     test_balance = 1000000
 
@@ -362,7 +351,6 @@ async def test_track_token(strategy):
 
 @pytest.mark.asyncio
 async def test_update_balance(strategy):
-    """Test that _update_balance updates tracked balances."""
     test_token_id = "test-token-base"
     initial_balance = 1000000
     updated_balance = 2000000
@@ -376,7 +364,6 @@ async def test_update_balance(strategy):
 
 @pytest.mark.asyncio
 async def test_get_non_zero_tracked_tokens(strategy):
-    """Test that _get_non_zero_tracked_tokens returns only non-zero balances."""
     strategy._track_token("token-1", 1000000)
     strategy._track_token("token-2", 0)
     strategy._track_token("token-3", 5000000)
@@ -392,7 +379,6 @@ async def test_get_non_zero_tracked_tokens(strategy):
 
 @pytest.mark.asyncio
 async def test_refresh_tracked_balances(strategy):
-    """Test that _refresh_tracked_balances updates all tracked token balances."""
     # Track some tokens
     strategy._track_token("usd-coin-base")
     strategy._track_token("ethereum-base")
@@ -407,7 +393,6 @@ async def test_refresh_tracked_balances(strategy):
 
 @pytest.mark.asyncio
 async def test_deposit_tracks_usdc(strategy):
-    """Test that deposit operation tracks USDC token."""
     # Clear tracked state
     strategy.tracked_token_ids.clear()
     strategy.tracked_balances.clear()
@@ -423,8 +408,6 @@ async def test_deposit_tracks_usdc(strategy):
 
 @pytest.mark.asyncio
 async def test_sweep_wallet_uses_tracked_tokens(strategy):
-    """Test that _sweep_wallet only swaps tracked tokens."""
-    # Import the real implementation to restore it
     from wayfinder_paths.strategies.stablecoin_yield_strategy.strategy import (
         StablecoinYieldStrategy,
     )
@@ -434,7 +417,6 @@ async def test_sweep_wallet_uses_tracked_tokens(strategy):
         strategy, StablecoinYieldStrategy
     )
 
-    # Setup: track some tokens with balances
     strategy._track_token("token-1", 1000000)
     strategy._track_token("token-2", 2000000)
 
@@ -447,10 +429,8 @@ async def test_sweep_wallet_uses_tracked_tokens(strategy):
     async def get_balance_mock(query, **kwargs):
         token_id = query if isinstance(query, str) else (query or {}).get("token_id")
         balance = strategy.tracked_balances.get(token_id, 0)
-        # Return the balance, ensuring it's an int
         return (True, int(balance) if balance else 0)
 
-    # Create a new AsyncMock that will track calls
     new_mock = AsyncMock(side_effect=get_balance_mock)
     strategy.balance_adapter.get_balance = new_mock
 
@@ -465,7 +445,6 @@ async def test_sweep_wallet_uses_tracked_tokens(strategy):
         "chain": {"code": "base", "name": "Base"},
     }
 
-    # Call sweep
     await strategy._sweep_wallet(target_token)
 
     # Verify that swap was called for tracked tokens (should be called twice, once for each token)
@@ -482,8 +461,6 @@ async def test_sweep_wallet_uses_tracked_tokens(strategy):
 
 @pytest.mark.asyncio
 async def test_get_non_gas_balances_uses_tracked_state(strategy):
-    """Test that _get_non_gas_balances only checks tracked tokens."""
-    # Setup tracked tokens
     usdc_token_id = "usd-coin-base"
     pool_token_id = "test-pool-base"
 
@@ -497,7 +474,6 @@ async def test_get_non_gas_balances_uses_tracked_state(strategy):
 
     strategy.balance_adapter.get_balance = AsyncMock(side_effect=_get_balance_effect)
 
-    # Get non-gas balances
     balances = await strategy._get_non_gas_balances()
 
     # Verify only tracked tokens are returned (excluding gas)
@@ -508,10 +484,8 @@ async def test_get_non_gas_balances_uses_tracked_state(strategy):
 
 @pytest.mark.asyncio
 async def test_partial_liquidate_uses_tracked_tokens(strategy):
-    """Test that partial_liquidate only liquidates tracked tokens."""
-    # Setup tracked tokens with balances
-    strategy._track_token("usd-coin-base", 50000000)  # 50 USDC
-    strategy._track_token("test-pool-base", 100000000000000000000)  # 100 POOL tokens
+    strategy._track_token("usd-coin-base", 50000000)
+    strategy._track_token("test-pool-base", 100000000000000000000)
 
     # Mock balance and token adapters
     def _get_balance_effect_partial(query, **kwargs):
@@ -530,7 +504,6 @@ async def test_partial_liquidate_uses_tracked_tokens(strategy):
         return_value=(True, "Swap successful")
     )
 
-    # Call partial liquidate
     ok, msg = await strategy.partial_liquidate(usd_value=75.0)
 
     # Verify success
@@ -540,12 +513,6 @@ async def test_partial_liquidate_uses_tracked_tokens(strategy):
 
 @pytest.mark.asyncio
 async def test_setup_handles_float_net_deposit(strategy):
-    """Test that setup() correctly handles float from get_strategy_net_deposit.
-
-    The ledger adapter returns (success, float) not (success, dict).
-    This test ensures the strategy doesn't try to call .get() on the float,
-    which would raise "'float' object has no attribute 'get'".
-    """
     # Mock get_strategy_net_deposit to return float (not dict)
     strategy.ledger_adapter.get_strategy_net_deposit = AsyncMock(
         return_value=(True, 1500.0)