wayfinder-paths 0.1.28__py3-none-any.whl → 0.1.30__py3-none-any.whl

wayfinder_paths/core/constants/hype_oft_abi.py

@@ -0,0 +1,151 @@
+"""LayerZero OFT ABI subset used for bridging native HYPE from HyperEVM."""
+
+HYPE_OFT_ABI = [
+    {
+        "inputs": [
+            {
+                "components": [
+                    {"internalType": "uint32", "name": "dstEid", "type": "uint32"},
+                    {"internalType": "bytes32", "name": "to", "type": "bytes32"},
+                    {"internalType": "uint256", "name": "amountLD", "type": "uint256"},
+                    {
+                        "internalType": "uint256",
+                        "name": "minAmountLD",
+                        "type": "uint256",
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "extraOptions",
+                        "type": "bytes",
+                    },
+                    {"internalType": "bytes", "name": "composeMsg", "type": "bytes"},
+                    {"internalType": "bytes", "name": "oftCmd", "type": "bytes"},
+                ],
+                "internalType": "struct SendParam",
+                "name": "_sendParam",
+                "type": "tuple",
+            },
+            {"internalType": "bool", "name": "_payInLzToken", "type": "bool"},
+        ],
+        "name": "quoteSend",
+        "outputs": [
+            {
+                "components": [
+                    {"internalType": "uint256", "name": "nativeFee", "type": "uint256"},
+                    {
+                        "internalType": "uint256",
+                        "name": "lzTokenFee",
+                        "type": "uint256",
+                    },
+                ],
+                "internalType": "struct MessagingFee",
+                "name": "",
+                "type": "tuple",
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "inputs": [
+            {
+                "components": [
+                    {"internalType": "uint32", "name": "dstEid", "type": "uint32"},
+                    {"internalType": "bytes32", "name": "to", "type": "bytes32"},
+                    {"internalType": "uint256", "name": "amountLD", "type": "uint256"},
+                    {
+                        "internalType": "uint256",
+                        "name": "minAmountLD",
+                        "type": "uint256",
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "extraOptions",
+                        "type": "bytes",
+                    },
+                    {"internalType": "bytes", "name": "composeMsg", "type": "bytes"},
+                    {"internalType": "bytes", "name": "oftCmd", "type": "bytes"},
+                ],
+                "internalType": "struct SendParam",
+                "name": "_sendParam",
+                "type": "tuple",
+            },
+            {
+                "components": [
+                    {"internalType": "uint256", "name": "nativeFee", "type": "uint256"},
+                    {
+                        "internalType": "uint256",
+                        "name": "lzTokenFee",
+                        "type": "uint256",
+                    },
+                ],
+                "internalType": "struct MessagingFee",
+                "name": "_fee",
+                "type": "tuple",
+            },
+            {"internalType": "address", "name": "_refundAddress", "type": "address"},
+        ],
+        "name": "send",
+        "outputs": [
+            {
+                "components": [
+                    {"internalType": "bytes32", "name": "guid", "type": "bytes32"},
+                    {"internalType": "uint64", "name": "nonce", "type": "uint64"},
+                    {
+                        "components": [
+                            {
+                                "internalType": "uint256",
+                                "name": "nativeFee",
+                                "type": "uint256",
+                            },
+                            {
+                                "internalType": "uint256",
+                                "name": "lzTokenFee",
+                                "type": "uint256",
+                            },
+                        ],
+                        "internalType": "struct MessagingFee",
+                        "name": "fee",
+                        "type": "tuple",
+                    },
+                ],
+                "internalType": "struct MessagingReceipt",
+                "name": "",
+                "type": "tuple",
+            },
+            {
+                "components": [
+                    {
+                        "internalType": "uint256",
+                        "name": "amountSentLD",
+                        "type": "uint256",
+                    },
+                    {
+                        "internalType": "uint256",
+                        "name": "amountReceivedLD",
+                        "type": "uint256",
+                    },
+                ],
+                "internalType": "struct OFTReceipt",
+                "name": "",
+                "type": "tuple",
+            },
+        ],
+        "stateMutability": "payable",
+        "type": "function",
+    },
+    {
+        "inputs": [],
+        "name": "sharedDecimals",
+        "outputs": [{"internalType": "uint8", "name": "", "type": "uint8"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "inputs": [],
+        "name": "decimalConversionRate",
+        "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+]

wayfinder_paths/core/constants/hyperliquid.py

@@ -2,10 +2,27 @@ from __future__ import annotations
 
 from typing import Any
 
-HYPERLIQUID_BRIDGE_ADDRESS: str = "0x2Df1c51E09aECF9cacB7bc98cB1742757f163dF7"
-ARBITRUM_USDC_ADDRESS: str = "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
+from wayfinder_paths.core.constants.contracts import (
+    ARBITRUM_USDC as ARBITRUM_USDC_ADDRESS,
+)
+from wayfinder_paths.core.constants.contracts import (
+    HYPE_FEE_WALLET,
+)
+from wayfinder_paths.core.constants.contracts import (
+    HYPERLIQUID_BRIDGE as HYPERLIQUID_BRIDGE_ADDRESS,
+)
+
+# Re-export addresses for backwards compatibility
+__all__ = [
+    "ARBITRUM_USDC_ADDRESS",
+    "ARBITRUM_USDC_TOKEN_ID",
+    "HYPE_FEE_WALLET",
+    "HYPERLIQUID_BRIDGE_ADDRESS",
+    "DEFAULT_HYPERLIQUID_BUILDER_FEE_TENTHS_BP",
+    "DEFAULT_HYPERLIQUID_BUILDER_FEE",
+]
+
 ARBITRUM_USDC_TOKEN_ID: str = "usd-coin-arbitrum"
-HYPE_FEE_WALLET: str = "0xaA1D89f333857eD78F8434CC4f896A9293EFE65c"
 
 # Tenths of a basis point: 30 -> 0.030% (3 bps)
 DEFAULT_HYPERLIQUID_BUILDER_FEE_TENTHS_BP: int = 30

wayfinder_paths/core/engine/manifest.py

@@ -19,7 +19,7 @@ class StrategyManifest(BaseModel):
     )
     name: str | None = Field(
         default=None,
-        description="Unique name identifier for this strategy instance. Used to look up dedicated wallet in wallets.json by label.",
+        description="Unique name identifier for this strategy instance. Used to look up dedicated wallet in config.json by label.",
     )
     permissions: dict[str, Any] = Field(default_factory=dict)
     adapters: list[AdapterRequirement] = Field(default_factory=list)

wayfinder_paths/core/strategies/Strategy.py

@@ -8,7 +8,6 @@ from loguru import logger
 
 from wayfinder_paths.core.clients.TokenClient import TokenDetails
 from wayfinder_paths.core.strategies.descriptors import StratDescriptor
-from wayfinder_paths.core.types import HyperliquidSignCallback
 
 
 class StatusDict(TypedDict):
@@ -52,7 +51,7 @@ class Strategy(ABC):
         main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
         strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
         | None = None,
-        strategy_sign_typed_data: HyperliquidSignCallback | None = None,
+        strategy_sign_typed_data: Callable[[dict], Awaitable[str]] | None = None,
     ):
         self.ledger_adapter = None
         self.logger = logger.bind(strategy=self.__class__.__name__)

wayfinder_paths/mcp/scripting.py

@@ -57,8 +57,8 @@ def get_adapter[T](
         wallet = find_wallet_by_label(wallet_label)
         if not wallet:
             raise ValueError(
-                f"Wallet '{wallet_label}' not found in wallets.json. "
-                "Run 'just create-wallets' or check WALLETS_PATH."
+                f"Wallet '{wallet_label}' not found in config.json. "
+                "Run 'just create-wallets'."
             )
 
         private_key = wallet.get("private_key") or wallet.get("private_key_hex")

wayfinder_paths/mcp/tools/discovery.py

@@ -6,12 +6,12 @@ from wayfinder_paths.mcp.utils import err, ok, read_text_excerpt, read_yaml, rep
 
 
 async def discover(
-    kind: Literal["adapters", "strategies"],
+    kind: Literal["adapter", "strategy"],
     detail: Literal["summary", "full"] = "summary",
 ) -> dict[str, Any]:
     root = repo_root()
     base = (
-        root / "wayfinder_paths" / ("adapters" if kind == "adapters" else "strategies")
+        root / "wayfinder_paths" / ("adapters" if kind == "adapter" else "strategies")
     )
     if not base.exists():
         return err("not_found", f"Directory not found: {base}")
@@ -26,7 +26,7 @@ async def discover(
         manifest = read_yaml(manifest_path)
         rel_manifest = str(manifest_path.relative_to(root))
 
-        if kind == "adapters":
+        if kind == "adapter":
             item = {
                 "name": child.name,
                 "entrypoint": manifest.get("entrypoint"),
@@ -58,75 +58,11 @@ async def discover(
     return ok({"kind": kind, "items": items})
 
 
-def _default_claude_notes_for_adapter(name: str) -> dict[str, Any] | None:
-    # Keep this deliberately small; the real docs live in .claude/skills.
-    if name == "brap_adapter":
-        return {
-            "reads": [
-                {
-                    "name": "quote_swap (via mcp__wayfinder__quote_swap)",
-                    "summary": "Get best BRAP route + fees; no on-chain effects.",
-                }
-            ],
-            "writes": [
-                {
-                    "name": "swap (via mcp__wayfinder__execute kind=swap)",
-                    "risk": "funds",
-                    "summary": "May submit ERC20 approvals and a swap/bridge tx.",
-                }
-            ],
-            "gotchas": [
-                "USDT-style tokens may require setting allowance to 0 before approve.",
-                "Cross-chain swaps still broadcast a tx on the source chain.",
-            ],
-        }
-    if name == "balance_adapter":
-        return {
-            "reads": [
-                {
-                    "name": "balances (via mcp__wayfinder__balances)",
-                    "summary": "Read token/pool balances via Wayfinder API.",
-                }
-            ],
-            "writes": [
-                {
-                    "name": "send (via mcp__wayfinder__execute kind=send)",
-                    "risk": "funds",
-                    "summary": "Native/ERC20 sends from a local wallet.",
-                }
-            ],
-            "gotchas": ["Prefer DRY_RUN=1 until ready to broadcast."],
-        }
-    if name == "hyperliquid_adapter":
-        return {
-            "reads": [
-                {
-                    "name": "hyperliquid (via mcp__wayfinder__hyperliquid)",
-                    "summary": "User state + market reads (no signing).",
-                }
-            ],
-            "writes": [
-                {
-                    "name": "hyperliquid_execute (via mcp__wayfinder__hyperliquid_execute)",
-                    "risk": "funds",
-                    "summary": "Perp orders/leverage/withdraw with local signing (gated by review prompt).",
-                }
-            ],
-            "gotchas": [
-                "Perp coins are mapped to asset_id (<10000).",
-                "Builder fees are attributed to 0xaA1D89f333857eD78F8434CC4f896A9293EFE65c and use tenths-of-bp units.",
-                "Prefer DRY_RUN=1 until ready to execute.",
-            ],
-        }
-    return None
-
-
 async def describe(
     kind: Literal["adapter", "strategy"],
     name: str,
     include_manifest: bool = True,
     include_readme_excerpt: bool = True,
-    include_claude_notes: bool = True,
 ) -> dict[str, Any]:
     root = repo_root()
     base = (
@@ -150,9 +86,4 @@ async def describe(
         if readme:
             out["readme_excerpt"] = readme
 
-    if include_claude_notes and kind == "adapter":
-        notes = _default_claude_notes_for_adapter(name)
-        if notes:
-            out["claude_notes"] = notes
-
     return ok(out)

wayfinder_paths/mcp/tools/execute.py

@@ -38,7 +38,7 @@ from wayfinder_paths.mcp.utils import (
 
 class ExecutionRequest(BaseModel):
     kind: Literal["swap", "send", "hyperliquid_deposit"]
-    wallet_label: str = Field(..., description="wallets.json label (e.g. main)")
+    wallet_label: str = Field(..., description="config.json wallet label (e.g. main)")
 
     # Shared
     amount: str = Field(..., description="Human units as a string (e.g. '1000')")
@@ -257,8 +257,10 @@ def _compact_quote(
     """Create a compact summary of quote data, stripping verbose nested structures."""
     result: dict[str, Any] = {}
 
-    # Extract provider list from all_quotes
-    all_quotes = quote_data.get("quotes", {}).get("all_quotes", [])
+    # Extract provider list from quotes (API returns quotes as a list at top level)
+    all_quotes = quote_data.get("quotes", [])
+    if not isinstance(all_quotes, list):
+        all_quotes = []
     if isinstance(all_quotes, list):
         result["providers"] = list(
             {
@@ -439,7 +441,7 @@ async def execute(
     if not sender or not pk:
         response = err(
             "invalid_wallet",
-            "Wallet must include address and private_key_hex in wallets.json (local dev only)",
+            "Wallet must include address and private_key_hex in config.json (local dev only)",
             {"wallet_label": req.wallet_label},
         )
         store.put(key, tool_input, response)
@@ -530,6 +532,8 @@ async def execute(
         swap_tx = dict(calldata)
         swap_tx["chainId"] = int(from_chain_id)
         swap_tx["from"] = to_checksum_address(sender)
+        if "value" in swap_tx:
+            swap_tx["value"] = int(swap_tx["value"])
 
         token_addr = from_token_addr
         spender = swap_tx.get("to")

wayfinder_paths/mcp/tools/hyperliquid.py

@@ -382,7 +382,7 @@ async def hyperliquid_execute(
     if not sender or not pk:
         response = err(
             "invalid_wallet",
-            "Wallet must include address and private_key_hex in wallets.json (local dev only)",
+            "Wallet must include address and private_key_hex in config.json (local dev only)",
             {"wallet_label": want},
         )
         store.put(key, tool_input, response)

wayfinder_paths/mcp/tools/quotes.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
-import re
 from typing import Any
 
 from wayfinder_paths.core.clients.BRAPClient import BRAPClient
 from wayfinder_paths.core.clients.TokenClient import TokenClient
-from wayfinder_paths.core.constants.chains import CHAIN_CODE_TO_ID
+from wayfinder_paths.mcp.tools.execute import (
+    _resolve_token_meta,
+    _select_token_chain,
+)
 from wayfinder_paths.mcp.utils import (
     err,
     find_wallet_by_label,
@@ -15,129 +17,6 @@ from wayfinder_paths.mcp.utils import (
 )
 
 
-def _chain_id(token: dict[str, Any]) -> int | None:
-    # Token payloads often include a database/internal `id` field; do not treat that as a chain id.
-    if token.get("chain_id") is not None:
-        try:
-            return int(token.get("chain_id"))
-        except (TypeError, ValueError):
-            return None
-
-    chain = token.get("chain") or {}
-    if not isinstance(chain, dict):
-        return None
-
-    for key in ("chain_id", "chainId", "id"):
-        if chain.get(key) is None:
-            continue
-        try:
-            return int(chain.get(key))
-        except (TypeError, ValueError):
-            return None
-
-    return None
-
-
-_SIMPLE_CHAIN_SUFFIX_RE = re.compile(r"^[a-z0-9]+\s+[a-z0-9-]+$", re.IGNORECASE)
-_ASSET_CHAIN_SPLIT_RE = re.compile(
-    r"^(?P<asset>[a-z0-9]+)[- _](?P<chain>[a-z0-9-]+)$", re.IGNORECASE
-)
-
-
-def _normalize_token_query(query: str) -> str:
-    q = " ".join(str(query).strip().split())
-    if not q or "-" in q or "_" in q:
-        return q
-    if not _SIMPLE_CHAIN_SUFFIX_RE.match(q):
-        return q
-    asset, chain_code = q.rsplit(" ", 1)
-    if chain_code.lower() in CHAIN_CODE_TO_ID:
-        return f"{asset}-{chain_code}"
-    return q
-
-
-def _is_eth_like_token(meta: dict[str, Any]) -> bool:
-    asset_id = str(meta.get("asset_id") or "").lower()
-    symbol = str(meta.get("symbol") or "").lower()
-    return asset_id == "ethereum" or symbol == "eth"
-
-
-def _split_asset_chain(query: str) -> tuple[str, str] | None:
-    q = str(query).strip()
-    if not q:
-        return None
-    m = _ASSET_CHAIN_SPLIT_RE.match(q)
-    if not m:
-        return None
-    return m.group("asset").lower(), m.group("chain").lower()
-
-
-async def _resolve_token_meta(
-    token_client: TokenClient,
-    *,
-    query: str,
-) -> tuple[str, dict[str, Any]]:
-    q = _normalize_token_query(query)
-    split = _split_asset_chain(q)
-    if split:
-        asset, chain_code = split
-        if asset in {"eth", "ethereum"}:
-            try:
-                gas_meta = await token_client.get_gas_token(chain_code)
-                if isinstance(gas_meta, dict) and _is_eth_like_token(gas_meta):
-                    return q, gas_meta
-            except Exception:
-                pass
-    meta = await token_client.get_token_details(q)
-    return q, meta
-
-
-def _infer_chain_code_from_query(query: str, meta: dict[str, Any]) -> str | None:
-    q = str(query).strip().lower()
-    if not q:
-        return None
-
-    candidates: set[str] = {str(k).lower() for k in CHAIN_CODE_TO_ID.keys()}
-    addrs = meta.get("addresses") or {}
-    if isinstance(addrs, dict):
-        candidates.update(str(k).lower() for k in addrs.keys())
-
-    best: str | None = None
-    for code in candidates:
-        if q.endswith(f"-{code}"):
-            if best is None or len(code) > len(best):
-                best = code
-    return best
-
-
-def _address_for_chain(meta: dict[str, Any], chain_code: str) -> str | None:
-    addrs = meta.get("addresses") or {}
-    if not isinstance(addrs, dict):
-        return None
-    for key, val in addrs.items():
-        if str(key).lower() == chain_code and val:
-            return str(val)
-    return None
-
-
-def _select_token_chain(
-    meta: dict[str, Any], *, query: str
-) -> tuple[int | None, str | None]:
-    chain_id = _chain_id(meta)
-    token_address = meta.get("address")
-
-    desired_chain = _infer_chain_code_from_query(query, meta)
-    if desired_chain:
-        addr = _address_for_chain(meta, desired_chain)
-        if addr:
-            token_address = addr
-        if desired_chain in CHAIN_CODE_TO_ID:
-            chain_id = CHAIN_CODE_TO_ID[desired_chain]
-
-    token_address_out = str(token_address).strip() if token_address else None
-    return chain_id, token_address_out
-
-
 def _slippage_float(slippage_bps: int) -> float:
     return max(0.0, float(int(slippage_bps)) / 10_000.0)
 
@@ -205,14 +84,13 @@ async def quote_swap(
     except Exception as exc:  # noqa: BLE001
         return err("quote_error", str(exc))
 
-    quotes_data = data.get("quotes", {}) if isinstance(data, dict) else {}
-    if not isinstance(quotes_data, dict):
-        quotes_data = {}
-    all_quotes = quotes_data.get("all_quotes", [])
-    if not isinstance(all_quotes, list):
-        all_quotes = []
-    best_quote = quotes_data.get("best_quote")
-    quote_count = quotes_data.get("quote_count", len(all_quotes))
+    # API returns {"quotes": [...], "best_quote": {...}} at top level
+    raw_quotes = data.get("quotes", []) if isinstance(data, dict) else []
+    if not isinstance(raw_quotes, list):
+        raw_quotes = []
+    all_quotes = raw_quotes
+    best_quote = data.get("best_quote") if isinstance(data, dict) else None
+    quote_count = len(all_quotes)
 
     providers: list[str] = []
     seen: set[str] = set()

wayfinder_paths/mcp/tools/wallets.py

@@ -14,7 +14,6 @@ from wayfinder_paths.mcp.utils import (
     normalize_address,
     ok,
     repo_root,
-    wallets_path,
 )
 
 PROTOCOL_ADAPTERS: dict[str, dict[str, Any]] = {
@@ -146,9 +145,7 @@ async def wallets(
     parallel: bool = False,
     include_zero_positions: bool = False,
 ) -> dict[str, Any]:
-    p = wallets_path()
     root = repo_root()
-    rel = str(p.relative_to(root)) if p.is_absolute() and root in p.parents else str(p)
     store = WalletProfileStore.default()
 
     if action == "list":
@@ -164,7 +161,7 @@ async def wallets(
             else:
                 view["protocols"] = []
             wallet_list.append(view)
-        return ok({"wallets_path": rel, "wallets": wallet_list})
+        return ok({"config_path": "config.json", "wallets": wallet_list})
 
     if action == "create":
         existing = load_wallets()
@@ -178,7 +175,7 @@ async def wallets(
             if str(w.get("label", "")).strip() == want:
                 return ok(
                     {
-                        "wallets_path": rel,
+                        "config_path": "config.json",
                         "wallets": [_public_wallet_view(x) for x in existing],
                         "created": _public_wallet_view(w),
                         "note": "Wallet label already existed; returning existing wallet.",
@@ -187,12 +184,12 @@ async def wallets(
 
         w = make_random_wallet()
         w["label"] = want
-        write_wallet_to_json(w, out_dir=p.parent, filename=p.name)
+        write_wallet_to_json(w, out_dir=root, filename="config.json")
 
         refreshed = load_wallets()
         return ok(
             {
-                "wallets_path": rel,
+                "config_path": "config.json",
                 "wallets": [_public_wallet_view(x) for x in refreshed],
                 "created": _public_wallet_view(w),
             }

wayfinder_paths/mcp/utils.py

@@ -64,32 +64,10 @@ def load_config_json() -> dict[str, Any]:
     return parsed if isinstance(parsed, dict) else {}
 
 
-def wallets_path() -> Path:
-    cfg = load_config_json()
-    system = cfg.get("system") if isinstance(cfg.get("system"), dict) else {}
-    candidate = (
-        (system or {}).get("wallets_path")
-        or os.getenv("WALLETS_PATH")
-        or "wallets.json"
-    )
-    p = Path(candidate)
-    if not p.is_absolute():
-        p = repo_root() / p
-    return p
-
-
 def load_wallets() -> list[dict[str, Any]]:
     cfg = load_config_json()
     if isinstance(cfg.get("wallets"), list):
         return [w for w in cfg["wallets"] if isinstance(w, dict)]
-
-    p = wallets_path()
-    if p.exists():
-        parsed = load_json_file(p)
-        if isinstance(parsed, list):
-            return [w for w in parsed if isinstance(w, dict)]
-        if isinstance(parsed, dict) and isinstance(parsed.get("wallets"), list):
-            return [w for w in parsed["wallets"] if isinstance(w, dict)]
     return []
 
 

wayfinder_paths/policies/lifi.py

@@ -1,7 +1,10 @@
+from wayfinder_paths.core.constants.contracts import (
+    LIFI_GENERIC,
+    LIFI_ROUTER_HYPEREVM,
+)
 from wayfinder_paths.policies.util import allow_functions
 
-LIFI_ROUTERS: dict[int:str] = {999: "0x0a0758d937d1059c356D4714e57F5df0239bce1A"}
-LIFI_GENERIC = "0x31a9b1835864706Af10103b31Ea2b79bdb995F5F"
+LIFI_ROUTERS: dict[int:str] = {999: LIFI_ROUTER_HYPEREVM}
 
 
 async def lifi_swap(chain_id):

wayfinder_paths/policies/moonwell.py

@@ -5,6 +5,7 @@ from wayfinder_paths.core.constants.contracts import (
     MOONWELL_M_WETH,
     MOONWELL_M_WSTETH,
 )
+from wayfinder_paths.core.constants.moonwell_abi import COMPTROLLER_ABI
 from wayfinder_paths.policies.util import allow_functions
 
 WETH = BASE_WETH
@@ -52,8 +53,9 @@ async def mwsteth_approve_or_mint_or_redeem():
 
 async def moonwell_comptroller_enter_markets_or_claim_rewards():
     return await allow_functions(
-        policy_name="Allow Moonwell Comptroller Enter Markets or Claim Rewards",
+        policy_name="Allow lend and claimReward",
         abi_chain_id=8453,
         address=COMPTROLLER,
         function_names=["enterMarkets", "claimReward"],
+        manual_abi=COMPTROLLER_ABI,
     )