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

wayfinder_paths/{vaults/adapters → adapters}/ledger_adapter/README.md

@@ -25,7 +25,7 @@ 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()

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

@@ -1,5 +1,5 @@
 schema_version: "0.1"
-entrypoint: "vaults.adapters.ledger_adapter.adapter.LedgerAdapter"
+entrypoint: "adapters.ledger_adapter.adapter.LedgerAdapter"
 capabilities:
   - "ledger.read"
   - "ledger.write"

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

@@ -2,7 +2,7 @@ from unittest.mock import AsyncMock, patch
 
 import pytest
 
-from wayfinder_paths.vaults.adapters.ledger_adapter.adapter import LedgerAdapter
+from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 
 
 class TestLedgerAdapter:
@@ -18,7 +18,7 @@ class TestLedgerAdapter:
     def adapter(self, mock_ledger_client):
         """Create a LedgerAdapter instance with mocked client for testing"""
         with patch(
-            "vaults.adapters.ledger_adapter.adapter.LedgerClient",
+            "adapters.ledger_adapter.adapter.LedgerClient",
             return_value=mock_ledger_client,
         ):
             return LedgerAdapter()

wayfinder_paths/{vaults/adapters → adapters}/pool_adapter/README.md

@@ -24,7 +24,7 @@ The PoolClient will automatically:
 ### Initialize the Adapter
 
 ```python
-from wayfinder_paths.vaults.adapters.pool_adapter.adapter import PoolAdapter
+from wayfinder_paths.adapters.pool_adapter.adapter import PoolAdapter
 
 # No configuration needed - uses PoolClient with automatic settings
 adapter = PoolAdapter()

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

@@ -1,5 +1,5 @@
 schema_version: "0.1"
-entrypoint: "vaults.adapters.pool_adapter.adapter.PoolAdapter"
+entrypoint: "adapters.pool_adapter.adapter.PoolAdapter"
 capabilities:
   - "pool.read"
   - "pool.analytics"

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

@@ -2,7 +2,7 @@ from unittest.mock import AsyncMock, patch
 
 import pytest
 
-from wayfinder_paths.vaults.adapters.pool_adapter.adapter import PoolAdapter
+from wayfinder_paths.adapters.pool_adapter.adapter import PoolAdapter
 
 
 class TestPoolAdapter:
@@ -18,7 +18,7 @@ class TestPoolAdapter:
     def adapter(self, mock_pool_client):
         """Create a PoolAdapter instance with mocked client for testing"""
         with patch(
-            "vaults.adapters.pool_adapter.adapter.PoolClient",
+            "adapters.pool_adapter.adapter.PoolClient",
             return_value=mock_pool_client,
         ):
             return PoolAdapter()

wayfinder_paths/{vaults/adapters → adapters}/token_adapter/README.md

@@ -20,7 +20,7 @@ The TokenClient will automatically:
 ### Initialize the Adapter
 
 ```python
-from wayfinder_paths.vaults.adapters.token_adapter.adapter import TokenAdapter
+from wayfinder_paths.adapters.token_adapter.adapter import TokenAdapter
 
 # No configuration needed - uses TokenClient with automatic settings
 adapter = TokenAdapter()

wayfinder_paths/adapters/token_adapter/examples.json

@@ -0,0 +1,26 @@
+{
+  "basic_usage": {
+    "description": "Basic usage of TokenAdapter to get token information",
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Get token by address\nsuccess, data = await adapter.get_token_by_address(\"0x1234567890abcdef1234567890abcdef12345678\")\nif success:\n    print(f\"Token symbol: {data.get('symbol')}\")\n    print(f\"Token name: {data.get('name')}\")\n    print(f\"Decimals: {data.get('decimals')}\")\nelse:\n    print(f\"Error: {data}\")"
+  },
+  "get_by_token_id": {
+    "description": "Get token information using token ID",
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Get token by ID\nsuccess, data = await adapter.get_token_by_id(\"token-12345\")\nif success:\n    print(f\"Token data: {data}\")\nelse:\n    print(f\"Error: {data}\")"
+  },
+  "flexible_lookup": {
+    "description": "Use flexible get_token method that tries both address and token_id",
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Try both address and token_id\nsuccess, data = await adapter.get_token(\n    address=\"0x1234567890abcdef1234567890abcdef12345678\",\n    token_id=\"token-12345\"\n)\nif success:\n    print(f\"Found token: {data}\")\nelse:\n    print(f\"Token not found: {data}\")"
+  },
+  "error_handling": {
+    "description": "Proper error handling for various scenarios",
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Handle missing parameters\ntry:\n    success, data = await adapter.get_token()\n    if not success:\n        print(f\"Error: {data}\")\nexcept Exception as e:\n    print(f\"Unexpected error: {e}\")\n\n# Handle API errors\nsuccess, data = await adapter.get_token_by_address(\"invalid-address\")\nif not success:\n    print(f\"API error: {data}\")\nelse:\n    print(f\"Token found: {data}\")"
+  },
+  "health_check": {
+    "description": "Check adapter health and connectivity",
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Check health\nhealth = await adapter.health_check()\nprint(f\"Adapter status: {health['status']}\")\nprint(f\"Connected: {health['connected']}\")\nprint(f\"Adapter type: {health['adapter']}\")\n\nif health['status'] == 'healthy':\n    print(\"Adapter is ready to use\")\nelse:\n    print(f\"Adapter has issues: {health.get('error', 'Unknown error')}\")"
+  },
+  "batch_operations": {
+    "description": "Perform multiple token lookups efficiently",
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\nimport asyncio\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# List of token addresses to lookup\ntoken_addresses = [\n    \"0x1234567890abcdef1234567890abcdef12345678\",\n    \"0xabcdef1234567890abcdef1234567890abcdef12\",\n    \"0x9876543210fedcba9876543210fedcba98765432\"\n]\n\n# Batch lookup\ntoken_data = {}\nfor address in token_addresses:\n    success, data = await adapter.get_token_by_address(address)\n    if success:\n        token_data[address] = data\n    else:\n        print(f\"Failed to get token for {address}: {data}\")\n\nprint(f\"Successfully retrieved {len(token_data)} tokens\")\nfor address, data in token_data.items():\n    print(f\"{address}: {data.get('symbol', 'Unknown')} - {data.get('name', 'Unknown')}\")"
+  }
+}

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

@@ -1,5 +1,5 @@
 schema_version: "0.1"
-entrypoint: "vaults.adapters.token_adapter.adapter.TokenAdapter"
+entrypoint: "adapters.token_adapter.adapter.TokenAdapter"
 capabilities:
   - "token.read"
 dependencies:

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

@@ -2,7 +2,7 @@ from unittest.mock import patch
 
 import pytest
 
-from wayfinder_paths.vaults.adapters.token_adapter.adapter import TokenAdapter
+from wayfinder_paths.adapters.token_adapter.adapter import TokenAdapter
 
 
 class TestTokenAdapter:

wayfinder_paths/config.example.json

@@ -2,10 +2,12 @@
     "user": {
       "username": "your_username",
       "password": "your_password",
-      "refresh_token": null
+      "refresh_token": null,
+      "api_key": "sk_live_abc123..."
     },
     "system": {
       "api_base_url": "https://wayfinder.ai/api/v1",
+      "api_key": "sk_live_abc123...",
       "wallets_path": "wallets.json"
     },
     "strategy": {

wayfinder_paths/core/engine/manifest.py

@@ -40,7 +40,7 @@ class StrategyManifest(BaseModel):
     schema_version: str = Field(default="0.1")
     entrypoint: str = Field(
         ...,
-        description="Python path to class, e.g. vaults.strategies.funding_rate_strategy.FundingRateStrategy",
+        description="Python path to class, e.g. strategies.funding_rate_strategy.FundingRateStrategy",
     )
     name: str | None = Field(
         default=None,

wayfinder_paths/core/strategies/Strategy.py

@@ -6,6 +6,7 @@ from typing import Any, TypedDict
 from loguru import logger
 
 from wayfinder_paths.core.services.base import Web3Service
+from wayfinder_paths.core.strategies.descriptors import StratDescriptor
 
 
 class StatusDict(TypedDict):
@@ -19,8 +20,7 @@ StatusTuple = tuple[bool, str]
 
 class Strategy(ABC):
     name: str = None
-    description: str = None
-    summary: str = None
+    INFO: StratDescriptor = None
 
     def __init__(
         self,
@@ -90,7 +90,7 @@ class Strategy(ABC):
         pass
 
     @staticmethod
-    def policies() -> list[str]:
+    async def policies() -> list[str]:
         """Return policy strings for this strategy (Django-compatible)."""
         raise NotImplementedError
 

wayfinder_paths/core/strategies/descriptors.py

@@ -0,0 +1,80 @@
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class Volatility(Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+class Frequency(Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+class Directionality(Enum):
+    LONG = "Long"
+    SHORT = "Short"
+    MARKET_NEUTRAL = "market_neutral"
+    DELTA_NEUTRAL = "delta_neutral"
+
+
+class Complexity(Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+class TokenExposure(Enum):
+    STABLECOINS = "Stablecoins"
+    MAJORS = "Majors"
+    ALTS = "Alts"
+
+
+# Default token rewards for all strategies
+DEFAULT_TOKEN_REWARDS = [
+    {
+        "symbol": "B3",
+        "name": "B3",
+        "address": "0xB3B3B3B3B3B3B3B3B3B3B3B3B3B3B3B3B3B3B3B3",
+        "image_url": "https://storage.googleapis.com/prod-wayfinder-app-assets/asset-icons/B3.png",
+    },
+]
+
+
+class StratDescriptor(BaseModel):
+    description: str
+
+    summary: str
+
+    gas_token_symbol: str
+    gas_token_id: str
+    deposit_token_id: str
+    minimum_net_deposit: float
+    gas_maximum: float
+    gas_threshold: float
+
+    available_rewards: dict[str, Any] = {
+        "token_rewards": DEFAULT_TOKEN_REWARDS,
+        "point_rewards": None,
+    }
+
+    # risk indicators
+    volatility: Volatility
+    volatility_description_short: str
+    directionality: Directionality
+    directionality_description: str
+    complexity: Complexity
+    complexity_description: str
+    token_exposure: TokenExposure
+    token_exposure_description: str
+    frequency: Frequency
+    frequency_description: str
+
+    return_drivers: list[str]
+
+    config: dict[str, Any]

wayfinder_paths/core/utils/evm_helpers.py

@@ -5,7 +5,9 @@ This module provides reusable functions for EVM-related operations that are shar
 across multiple adapters, extracted from evm_transaction_adapter.
 """
 
+import json
 import os
+from pathlib import Path
 from typing import Any
 
 from loguru import logger
@@ -163,3 +165,40 @@ def resolve_private_key_for_from_address(
 
     # Fallback to environment variables
     return os.getenv("PRIVATE_KEY_VAULT") or os.getenv("PRIVATE_KEY")
+
+
+async def _get_abi(chain_id: int, address: str) -> str | None:
+    os.makedirs(f"abis/{chain_id}/", exist_ok=True)
+
+    abi_file = f"abis/{chain_id}/{address}.json"
+    if not os.path.exists(abi_file):
+        raise ValueError(
+            f"There is no downloaded ABI for {address} on chain {chain_id} -- please download it to ({abi_file})  (make sure to get the implementation if this address is a proxy)"
+        )
+
+    with open(abi_file) as f:
+        abi = f.read()
+
+    return abi
+
+
+# We filter ABIs for Privy Policy since most of the abi is useless, and we don't wanna upload big ABIs for both size and readability reasons.
+async def get_abi_filtered(
+    chain_id: int, address: str, function_names: list[str]
+) -> list | None:
+    full_abi = await _get_abi(chain_id, address)
+    if full_abi is None:
+        raise Exception("Could not pull ABI, get_abi returned None")
+    abi_json = json.loads(full_abi)
+    filtered_abi = [
+        item
+        for item in abi_json
+        if item.get("type") == "function" and item.get("name") in function_names
+    ]
+    return filtered_abi
+
+
+with open(Path(__file__).parent.parent.parent.joinpath("abis/generic/erc20.json")) as f:
+    erc20_abi_raw = f.read()
+
+ERC20_ABI = json.loads(erc20_abi_raw)

wayfinder_paths/policies/enso.py

@@ -0,0 +1,17 @@
+from wayfinder_paths.policies.util import allow_functions
+
+ENSO_ROUTER = "0xf75584ef6673ad213a685a1b58cc0330b8ea22cf"
+
+
+async def enso_swap():
+    return await allow_functions(
+        policy_name="Allow Enso Swap",
+        abi_chain_id=8453,
+        address=ENSO_ROUTER,
+        function_names=[
+            "routeMulti",
+            "routeSingle",
+            "safeRouteMulti",
+            "safeRouteSingle",
+        ],
+    )

wayfinder_paths/policies/erc20.py

@@ -0,0 +1,34 @@
+from wayfinder_paths.core.utils.evm_helpers import ERC20_ABI
+
+
+def any_erc20_function(token_address: str) -> dict:
+    return {
+        "name": "Allow Any ERC20 Transfer To Address",
+        "method": "eth_signTransaction",
+        "action": "ALLOW",
+        "conditions": [
+            {
+                "field_source": "ethereum_transaction",
+                "field": "to",
+                "operator": "eq",
+                "value": token_address,
+            }
+        ],
+    }
+
+
+def erc20_spender_for_any_token(spender_address: str) -> dict:
+    return {
+        "name": "Allow Any ERC20 Approve To Spender",
+        "method": "eth_signTransaction",
+        "action": "ALLOW",
+        "conditions": [
+            {
+                "field_source": "ethereum_calldata",
+                "field": "approve.spender",
+                "abi": ERC20_ABI,
+                "operator": "eq",
+                "value": spender_address,
+            },
+        ],
+    }

wayfinder_paths/policies/evm.py

@@ -0,0 +1,21 @@
+def native_transfer(destination_address: str, value: int) -> dict:
+    # TODO THIS FUNCTION IS NOT DONE CAUSE POLICIES DONT KNOW THE WALLET ADDRESS YET.
+    return {
+        "name": "Allow Native Transfer To Address",
+        "method": "eth_signTransaction",
+        "action": "ALLOW",
+        "conditions": [
+            {
+                "field_source": "ethereum_transaction",
+                "field": "to",
+                "operator": "eq",
+                "value": destination_address,
+            },
+            {
+                "field_source": "ethereum_transaction",
+                "field": "value",
+                "operator": "eq",
+                "value": hex(value),
+            },
+        ],
+    }

wayfinder_paths/policies/hyper_evm.py

@@ -0,0 +1,19 @@
+from wayfinder_paths.policies.evm import native_transfer
+from wayfinder_paths.policies.util import allow_functions
+
+WHYPE_TOKEN = "0x5555555555555555555555555555555555555555"
+HYPERCORE_SENTINEL_ADDRESS = "0x2222222222222222222222222222222222222222"
+HYPERCORE_SENTINEL_VALUE = 100_000_000_000
+
+
+def hypecore_sentinel_deposit():
+    return native_transfer(HYPERCORE_SENTINEL_ADDRESS, HYPERCORE_SENTINEL_VALUE)
+
+
+async def whype_deposit_and_withdraw():
+    return await allow_functions(
+        policy_name="Allow WHYPE Deposit and Withdraw",
+        abi_chain_id=999,
+        address=WHYPE_TOKEN,
+        function_names=["deposit", "withdraw"],
+    )

wayfinder_paths/policies/hyperlend.py

@@ -0,0 +1,12 @@
+from wayfinder_paths.policies.util import allow_functions
+
+HYPERLEND_POOL = "0x00A89d7a5A02160f20150EbEA7a2b5E4879A1A8b"
+
+
+async def hyperlend_supply_and_withdraw():
+    return await allow_functions(
+        policy_name="Allow Hyperlend Supply and Withdraw",
+        abi_chain_id=999,
+        address=HYPERLEND_POOL,
+        function_names=["supply", "withdraw"],
+    )

wayfinder_paths/policies/hyperliquid.py

@@ -0,0 +1,30 @@
+def any_hyperliquid_l1_payload():
+    return {
+        "name": "Allow Hypecore L1 Payload",
+        "method": "eth_signTypedData_v4",
+        "action": "ALLOW",
+        "conditions": [
+            {
+                "field": "chainId",
+                "field_source": "ethereum_typed_data_domain",
+                "operator": "eq",
+                "value": "1337",
+            }
+        ],
+    }
+
+
+def any_hyperliquid_user_payload():
+    return {
+        "name": "Allow User Signed Payload",
+        "method": "eth_signTypedData_v4",
+        "action": "ALLOW",
+        "conditions": [
+            {
+                "field": "chainId",
+                "field_source": "ethereum_typed_data_domain",
+                "operator": "eq",
+                "value": "421614",
+            }
+        ],
+    }

wayfinder_paths/policies/moonwell.py

@@ -0,0 +1,54 @@
+from wayfinder_paths.policies.util import allow_functions
+
+WETH = "0x4200000000000000000000000000000000000006"
+
+M_USDC = "0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22"
+M_WETH = "0x628ff693426583D9a7FB391E54366292F509D457"
+M_WSTETH = "0x627Fe393Bc6EdDA28e99AE648fD6fF362514304b"
+
+COMPTROLLER = "0xfbb21d0380bee3312b33c4353c8936a0f13ef26c"
+
+
+async def weth_deposit():
+    return await allow_functions(
+        policy_name="Allow WETH Deposit",
+        abi_chain_id=8453,
+        address=WETH,
+        function_names=["deposit"],
+    )
+
+
+async def musdc_mint_or_approve_or_redeem():
+    return await allow_functions(
+        policy_name="Allow MUSDC Mint or Approve or Redeem",
+        abi_chain_id=8453,
+        address=M_USDC,
+        function_names=["mint", "approve", "redeem"],
+    )
+
+
+async def mweth_approve_or_borrow_or_repay():
+    return await allow_functions(
+        policy_name="Allow MWETH Approve or Borrow or Repay",
+        abi_chain_id=8453,
+        address=M_WETH,
+        function_names=["approve", "borrow", "repayBorrow"],
+    )
+
+
+async def mwsteth_approve_or_mint_or_redeem():
+    return await allow_functions(
+        policy_name="Allow MWSTETH Approve or Mint or Redeem",
+        abi_chain_id=8453,
+        address=M_WSTETH,
+        function_names=["approve", "mint", "redeem"],
+    )
+
+
+async def moonwell_comptroller_enter_markets_or_claim_rewards():
+    return await allow_functions(
+        policy_name="Allow Moonwell Comptroller Enter Markets or Claim Rewards",
+        abi_chain_id=8453,
+        address=COMPTROLLER,
+        function_names=["enterMarkets", "claimReward"],
+    )

wayfinder_paths/policies/prjx.py

@@ -0,0 +1,30 @@
+from wayfinder_paths.policies.util import allow_functions
+
+PRJX_ROUTER = "0x1ebdfc75ffe3ba3de61e7138a3e8706ac841af9b"
+PRJX_NPM = "0xeAd19AE861c29bBb2101E834922B2FEee69B9091"
+
+
+async def prjx_swap():
+    return await allow_functions(
+        policy_name="Allow PRJX Swap",
+        abi_chain_id=999,
+        address=PRJX_ROUTER,
+        function_names=[
+            "exactInput",
+            "exactInputSingle",
+            "exactOutput",
+            "exactOutputSingle",
+        ],
+    )
+
+
+async def prjx_npm():
+    return await allow_functions(
+        policy_name="Allow PRJX NPM",
+        abi_chain_id=999,
+        address=PRJX_NPM,
+        function_names=[
+            "increaseLiquidity",
+            "decreaseLiquidity",
+        ],
+    )

wayfinder_paths/policies/util.py

@@ -0,0 +1,27 @@
+from wayfinder_paths.core.utils.evm_helpers import get_abi_filtered
+
+
+async def allow_functions(
+    policy_name: str, abi_chain_id: int, address: str, function_names: list[str]
+):
+    # Note: ChainID is just for fetching ABI, doesn't appear in the final policy. Doesn't bind a strict chain.
+    return {
+        "name": policy_name,
+        "method": "eth_signTransaction",
+        "action": "ALLOW",
+        "conditions": [
+            {
+                "field_source": "ethereum_transaction",
+                "field": "to",
+                "operator": "eq",
+                "value": address,
+            },
+            {
+                "field_source": "ethereum_calldata",
+                "field": "function_name",
+                "abi": await get_abi_filtered(abi_chain_id, address, function_names),
+                "operator": "in",
+                "value": function_names,
+            },
+        ],
+    }

wayfinder_paths/run_strategy.py

@@ -28,7 +28,7 @@ def load_strategy(
     Dynamically load a strategy by name using its manifest
 
     Args:
-        strategy_name: Name of the strategy to load (directory name in vaults/strategies/)
+        strategy_name: Name of the strategy to load (directory name in strategies/)
         strategy_config: Configuration dict for the strategy
         simulation: Enable simulation mode for testing
         api_key: Optional API key for service account authentication
@@ -37,7 +37,7 @@ def load_strategy(
         Strategy instance
     """
     # Find strategy manifest by scanning for manifest.yaml in the strategy directory
-    strategies_dir = Path(__file__).parent / "vaults" / "strategies"
+    strategies_dir = Path(__file__).parent / "strategies"
     strategy_dir = strategies_dir / strategy_name
     manifest_path = strategy_dir / "manifest.yaml"
 
@@ -120,7 +120,7 @@ async def run_strategy(
             # Extract directory name from manifest path for wallet lookup
             # Use the directory name (strategy identifier) for wallet lookup
             manifest_dir = Path(manifest_path).parent
-            strategies_dir = Path(__file__).parent / "vaults" / "strategies"
+            strategies_dir = Path(__file__).parent / "strategies"
             try:
                 # Try to get relative path - if it's under strategies_dir, use directory name
                 rel_path = manifest_dir.relative_to(strategies_dir)

wayfinder_paths/scripts/create_strategy.py

@@ -64,13 +64,13 @@ def main():
     parser.add_argument(
         "--template-dir",
         type=Path,
-        default=Path(__file__).parent.parent / "vaults" / "templates" / "strategy",
+        default=Path(__file__).parent.parent / "templates" / "strategy",
         help="Path to strategy template directory",
     )
     parser.add_argument(
         "--strategies-dir",
         type=Path,
-        default=Path(__file__).parent.parent / "vaults" / "strategies",
+        default=Path(__file__).parent.parent / "strategies",
         help="Path to strategies directory",
     )
     parser.add_argument(
@@ -136,7 +136,7 @@ def main():
         print(f"  Updated strategy.py with class name: {class_name}")
 
     # Generate entrypoint path
-    entrypoint = f"vaults.strategies.{dir_name}.strategy.{class_name}"
+    entrypoint = f"strategies.{dir_name}.strategy.{class_name}"
 
     # Update manifest with name (using directory name) and entrypoint
     manifest_path = strategy_dir / "manifest.yaml"

wayfinder_paths/scripts/validate_manifests.py

@@ -138,7 +138,7 @@ def validate_strategy_manifest(manifest_path: str) -> tuple[bool, list[str]]:
 def find_adapter_manifests() -> list[Path]:
     """Find all adapter manifest files."""
     manifests = []
-    adapter_dir = Path(__file__).parent.parent / "vaults" / "adapters"
+    adapter_dir = Path(__file__).parent.parent / "adapters"
     if adapter_dir.exists():
         for adapter_path in adapter_dir.iterdir():
             manifest_path = adapter_path / "manifest.yaml"
@@ -150,7 +150,7 @@ def find_adapter_manifests() -> list[Path]:
 def find_strategy_manifests() -> list[Path]:
     """Find all strategy manifest files."""
     manifests = []
-    strategy_dir = Path(__file__).parent.parent / "vaults" / "strategies"
+    strategy_dir = Path(__file__).parent.parent / "strategies"
     if strategy_dir.exists():
         for strategy_path in strategy_dir.iterdir():
             manifest_path = strategy_path / "manifest.yaml"

wayfinder_paths/{vaults/strategies → strategies}/hyperlend_stable_yield_strategy/README.md

@@ -1,6 +1,6 @@
 # Hyperlend Stable Yield Strategy
 
-- Entrypoint: `vaults.strategies.hyperlend_stable_yield_strategy.strategy.HyperlendStableYieldStrategy`
+- Entrypoint: `strategies.hyperlend_stable_yield_strategy.strategy.HyperlendStableYieldStrategy`
 - Manifest: `manifest.yaml`
 - Examples: `examples.json`
 - Tests: `test_strategy.py`
@@ -75,8 +75,9 @@ The manifest policy simply locks transactions to the vault wallet ID:
 # Install dependencies
 poetry install
 
-# Generate default + vault wallets (writes wallets.json)
-poetry run python wayfinder_paths/scripts/make_wallets.py --default --vault
+# Generate main wallet (writes wallets.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
 
 # Copy config and edit credentials (or rely on env vars)
 cp wayfinder_paths/config.example.json config.json