hyperliquid-cli-python 0.1.0__py3-none-any.whl

hl_cli/core/__init__.py

@@ -0,0 +1 @@
+"""Core application services."""

hl_cli/core/context.py

@@ -0,0 +1,156 @@
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+from eth_account import Account as EthAccount
+from hyperliquid.exchange import Exchange
+from hyperliquid.info import Info
+from hyperliquid.utils.constants import MAINNET_API_URL, TESTNET_API_URL
+import requests
+
+from ..infra.db import Account, get_default_account
+
+
+@dataclass
+class Config:
+    private_key: Optional[str]
+    wallet_address: Optional[str]
+    testnet: bool
+    account: Optional[Account]
+
+
+class CLIContext:
+    def __init__(self, config: Config):
+        self.config = config
+        self._info: Optional[Info] = None
+        self._multi_perp_info: Optional[Info] = None
+        self._exchange_clients: dict[tuple[str, ...], Exchange] = {}
+        self._perp_dexs: Optional[list[str]] = None
+
+    @property
+    def base_url(self) -> str:
+        return TESTNET_API_URL if self.config.testnet else MAINNET_API_URL
+
+    def get_public_client(self) -> Info:
+        if self._info is None:
+            self._info = _build_info_client(self.base_url, skip_ws=True)
+        return self._info
+
+    def get_multi_perp_public_client(self) -> Info:
+        if self._multi_perp_info is None:
+            self._multi_perp_info = _build_info_client(
+                self.base_url,
+                skip_ws=True,
+                perp_dexs=self.get_perp_dexs(),
+            )
+        return self._multi_perp_info
+
+    def get_wallet_client(self, perp_dexs: Optional[list[str]] = None) -> Exchange:
+        key = tuple(perp_dexs or [])
+        if key not in self._exchange_clients:
+            if not self.config.private_key:
+                if self.config.account and self.config.account.type == "readonly":
+                    raise RuntimeError(
+                        f'Account "{self.config.account.alias}" is read-only and cannot trade. '
+                        "Use 'hl account add' to add an API wallet."
+                    )
+                raise RuntimeError("No account configured. Run 'hl account add'.")
+            wallet = EthAccount.from_key(self.config.private_key)
+            kwargs = {
+                "wallet": wallet,
+                "base_url": self.base_url,
+                "account_address": self.get_wallet_address(),
+            }
+            if perp_dexs is not None:
+                kwargs["perp_dexs"] = perp_dexs
+            try:
+                self._exchange_clients[key] = Exchange(**kwargs)
+            except IndexError:
+                self._exchange_clients[key] = Exchange(
+                    **kwargs,
+                    spot_meta=_load_safe_spot_meta(self.base_url),
+                )
+        return self._exchange_clients[key]
+
+    def get_perp_dexs(self) -> list[str]:
+        if self._perp_dexs is not None:
+            return self._perp_dexs
+        try:
+            temp = _build_info_client(self.base_url, skip_ws=True)
+            raw = temp.perp_dexs()
+            names = [str(x.get("name")) for x in raw if isinstance(x, dict) and x.get("name")]
+            self._perp_dexs = ["", *names] if names else [""]
+        except Exception:
+            self._perp_dexs = [""]
+        return self._perp_dexs
+
+    def get_wallet_address(self) -> str:
+        if self.config.wallet_address:
+            return self.config.wallet_address
+        if self.config.private_key:
+            return EthAccount.from_key(self.config.private_key).address
+        raise RuntimeError("No account configured. Run 'hl account add'.")
+
+
+def load_config(testnet: bool) -> Config:
+    network = "testnet" if testnet else "mainnet"
+    default = None
+    try:
+        default = get_default_account(network)
+    except Exception:
+        default = None
+
+    if default:
+        return Config(
+            private_key=default.api_wallet_private_key,
+            wallet_address=default.user_address,
+            testnet=testnet,
+            account=default,
+        )
+
+    private_key = os.getenv("HYPERLIQUID_PRIVATE_KEY")
+    wallet_address = os.getenv("HYPERLIQUID_WALLET_ADDRESS")
+
+    if private_key and not wallet_address:
+        wallet_address = EthAccount.from_key(private_key).address
+
+    return Config(
+        private_key=private_key,
+        wallet_address=wallet_address,
+        testnet=testnet,
+        account=None,
+    )
+
+
+def _load_safe_spot_meta(base_url: str) -> dict:
+    # Testnet currently returns some spot pairs with invalid token indexes.
+    # Filter those out before constructing the SDK client.
+    response = requests.post(f"{base_url}/info", json={"type": "spotMeta"}, timeout=20)
+    response.raise_for_status()
+    spot_meta = response.json()
+    tokens = spot_meta.get("tokens", [])
+    max_idx = len(tokens) - 1
+
+    safe_universe = []
+    for pair in spot_meta.get("universe", []):
+        refs = pair.get("tokens")
+        if not isinstance(refs, list) or len(refs) < 2:
+            continue
+        if any(not isinstance(ref, int) or ref < 0 or ref > max_idx for ref in refs[:2]):
+            continue
+        safe_universe.append(pair)
+
+    return {
+        **spot_meta,
+        "universe": safe_universe,
+    }
+
+
+def _build_info_client(base_url: str, **kwargs: object) -> Info:
+    try:
+        return Info(base_url, **kwargs)
+    except IndexError:
+        # Testnet-only defensive fallback for malformed spot metadata.
+        if "spot_meta" in kwargs:
+            raise
+        return Info(base_url, spot_meta=_load_safe_spot_meta(base_url), **kwargs)

hl_cli/core/order_config.py

@@ -0,0 +1,23 @@
+import json
+
+from ..infra.paths import HL_DIR, ORDER_CONFIG_PATH
+
+DEFAULT_CONFIG = {"slippage": 1.0}
+
+
+def get_order_config() -> dict:
+    if not ORDER_CONFIG_PATH.exists():
+        return dict(DEFAULT_CONFIG)
+    try:
+        data = json.loads(ORDER_CONFIG_PATH.read_text())
+        return {**DEFAULT_CONFIG, **data}
+    except Exception:
+        return dict(DEFAULT_CONFIG)
+
+
+def update_order_config(**updates: object) -> dict:
+    HL_DIR.mkdir(parents=True, exist_ok=True)
+    cfg = get_order_config()
+    cfg.update(updates)
+    ORDER_CONFIG_PATH.write_text(json.dumps(cfg, indent=2))
+    return cfg

hl_cli/infra/__init__.py

@@ -0,0 +1 @@
+"""Infrastructure adapters and persistence."""

hl_cli/infra/db.py

@@ -0,0 +1,277 @@
+import base64
+import hashlib
+import sqlite3
+from dataclasses import dataclass
+from pathlib import Path
+import secrets
+import shutil
+import sys
+from typing import Optional
+
+from Crypto.Cipher import ChaCha20
+
+from .paths import DB_PATH, HL_DIR
+
+
+@dataclass
+class Account:
+    id: int
+    alias: str
+    network: str
+    user_address: str
+    type: str
+    source: str
+    api_wallet_private_key: Optional[str]
+    api_wallet_public_key: Optional[str]
+    is_default: bool
+    created_at: int
+    updated_at: int
+
+
+_ENC_PREFIX = "enc_v1:"
+
+
+def _conn() -> sqlite3.Connection:
+    HL_DIR.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    _migrate(conn)
+    # TODO: Remove this compatibility migration after all existing plaintext
+    # account rows have been rewritten to encrypted storage.
+    _migrate_encrypted_account_fields(conn)
+    return conn
+
+
+def _migrate(conn: sqlite3.Connection) -> None:
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS accounts (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          alias TEXT NOT NULL UNIQUE,
+          network TEXT NOT NULL DEFAULT 'mainnet' CHECK (network IN ('mainnet', 'testnet')),
+          user_address TEXT NOT NULL,
+          type TEXT NOT NULL CHECK (type IN ('readonly', 'api_wallet')),
+          source TEXT NOT NULL DEFAULT 'cli_import',
+          api_wallet_private_key TEXT,
+          api_wallet_public_key TEXT,
+          is_default INTEGER NOT NULL DEFAULT 0,
+          created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
+          updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
+        )
+        """
+    )
+    columns = {
+        row["name"]
+        for row in conn.execute("PRAGMA table_info(accounts)").fetchall()
+    }
+    # TODO: Remove this compatibility migration after all existing databases have
+    # been migrated to include the network column.
+    if "network" not in columns:
+        conn.execute("ALTER TABLE accounts ADD COLUMN network TEXT NOT NULL DEFAULT 'mainnet'")
+    conn.commit()
+
+
+def _to_account(row: sqlite3.Row) -> Account:
+    return Account(
+        id=row["id"],
+        alias=row["alias"],
+        network=row["network"],
+        user_address=_decrypt_value(row["user_address"]),
+        type=row["type"],
+        source=row["source"],
+        api_wallet_private_key=_decrypt_optional_value(row["api_wallet_private_key"]),
+        api_wallet_public_key=_decrypt_optional_value(row["api_wallet_public_key"]),
+        is_default=bool(row["is_default"]),
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+    )
+
+
+def get_all_accounts(network: str) -> list[Account]:
+    conn = _conn()
+    rows = conn.execute(
+        "SELECT * FROM accounts WHERE network = ? ORDER BY is_default DESC, created_at ASC",
+        (network,),
+    ).fetchall()
+    conn.close()
+    return [_to_account(r) for r in rows]
+
+
+def get_account_by_alias(alias: str, network: str) -> Optional[Account]:
+    conn = _conn()
+    row = conn.execute("SELECT * FROM accounts WHERE alias = ? AND network = ?", (alias, network)).fetchone()
+    conn.close()
+    return _to_account(row) if row else None
+
+
+def get_default_account(network: str) -> Optional[Account]:
+    conn = _conn()
+    row = conn.execute("SELECT * FROM accounts WHERE network = ? AND is_default = 1 LIMIT 1", (network,)).fetchone()
+    conn.close()
+    return _to_account(row) if row else None
+
+
+def get_account_count(network: str) -> int:
+    conn = _conn()
+    count = conn.execute("SELECT COUNT(*) AS c FROM accounts WHERE network = ?", (network,)).fetchone()["c"]
+    conn.close()
+    return int(count)
+
+
+def is_alias_taken(alias: str, network: str) -> bool:
+    return get_account_by_alias(alias, network) is not None
+
+
+def create_account(
+    *,
+    alias: str,
+    network: str,
+    user_address: str,
+    account_type: str,
+    source: str = "cli_import",
+    api_wallet_private_key: str | None = None,
+    api_wallet_public_key: str | None = None,
+    set_as_default: bool = False,
+) -> Account:
+    conn = _conn()
+    count = conn.execute("SELECT COUNT(*) AS c FROM accounts WHERE network = ?", (network,)).fetchone()["c"]
+    should_be_default = count == 0 or set_as_default
+    if should_be_default:
+        conn.execute("UPDATE accounts SET is_default = 0 WHERE network = ? AND is_default = 1", (network,))
+    conn.execute(
+        """
+        INSERT INTO accounts (
+            alias, network, user_address, type, source,
+            api_wallet_private_key, api_wallet_public_key, is_default
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            alias,
+            network,
+            _encrypt_value(user_address),
+            account_type,
+            source,
+            _encrypt_optional_value(api_wallet_private_key),
+            _encrypt_optional_value(api_wallet_public_key),
+            1 if should_be_default else 0,
+        ),
+    )
+    conn.commit()
+    row = conn.execute("SELECT * FROM accounts WHERE alias = ? AND network = ?", (alias, network)).fetchone()
+    conn.close()
+    return _to_account(row)
+
+
+def set_default_account(alias: str, network: str) -> Account:
+    conn = _conn()
+    conn.execute("UPDATE accounts SET is_default = 0 WHERE network = ? AND is_default = 1", (network,))
+    conn.execute(
+        "UPDATE accounts SET is_default = 1, updated_at = strftime('%s', 'now') WHERE alias = ? AND network = ?",
+        (alias, network),
+    )
+    conn.commit()
+    row = conn.execute("SELECT * FROM accounts WHERE alias = ? AND network = ?", (alias, network)).fetchone()
+    conn.close()
+    if not row:
+        raise ValueError(f'Account with alias "{alias}" not found')
+    return _to_account(row)
+
+
+def delete_account(alias: str, network: str) -> bool:
+    conn = _conn()
+    row = conn.execute("SELECT * FROM accounts WHERE alias = ? AND network = ?", (alias, network)).fetchone()
+    if not row:
+        conn.close()
+        return False
+    was_default = bool(row["is_default"])
+    conn.execute("DELETE FROM accounts WHERE alias = ? AND network = ?", (alias, network))
+    if was_default:
+        first = conn.execute(
+            "SELECT id FROM accounts WHERE network = ? ORDER BY created_at ASC LIMIT 1",
+            (network,),
+        ).fetchone()
+        if first:
+            conn.execute("UPDATE accounts SET is_default = 1 WHERE id = ?", (first["id"],))
+    conn.commit()
+    conn.close()
+    return True
+
+
+def _command_path_for_key() -> str:
+    argv0 = sys.argv[0]
+    resolved = shutil.which(argv0) if argv0 and "/" not in argv0 else argv0
+    if not resolved:
+        resolved = argv0
+    return str(Path(resolved or "hl").resolve())
+
+
+def _chacha20_key() -> bytes:
+    # Derive the encryption key from the current command path so only the same
+    # installed command path can transparently decrypt the stored account data.
+    return hashlib.sha256(_command_path_for_key().encode("utf-8")).digest()
+
+
+def _encrypt_value(value: str) -> str:
+    nonce = secrets.token_bytes(12)
+    cipher = ChaCha20.new(key=_chacha20_key(), nonce=nonce)
+    encrypted = cipher.encrypt(value.encode("utf-8"))
+    return f"{_ENC_PREFIX}{base64.urlsafe_b64encode(nonce).decode()}:{base64.urlsafe_b64encode(encrypted).decode()}"
+
+
+def _decrypt_value(value: str) -> str:
+    if not value.startswith(_ENC_PREFIX):
+        return value
+    payload = value[len(_ENC_PREFIX):]
+    nonce_b64, encrypted_b64 = payload.split(":", 1)
+    nonce = base64.urlsafe_b64decode(nonce_b64.encode())
+    encrypted = base64.urlsafe_b64decode(encrypted_b64.encode())
+    cipher = ChaCha20.new(key=_chacha20_key(), nonce=nonce)
+    return cipher.decrypt(encrypted).decode("utf-8")
+
+
+def _encrypt_optional_value(value: Optional[str]) -> Optional[str]:
+    if value is None:
+        return None
+    return _encrypt_value(value)
+
+
+def _decrypt_optional_value(value: Optional[str]) -> Optional[str]:
+    if value is None:
+        return None
+    return _decrypt_value(value)
+
+
+def _migrate_encrypted_account_fields(conn: sqlite3.Connection) -> None:
+    # TODO: Remove this whole function after all existing plaintext account rows
+    # have been migrated to encrypted storage.
+    rows = conn.execute(
+        """
+        SELECT id, user_address, api_wallet_private_key, api_wallet_public_key
+        FROM accounts
+        """
+    ).fetchall()
+    for row in rows:
+        user_address = row["user_address"]
+        api_wallet_private_key = row["api_wallet_private_key"]
+        api_wallet_public_key = row["api_wallet_public_key"]
+        if (
+            isinstance(user_address, str)
+            and user_address.startswith(_ENC_PREFIX)
+            and (api_wallet_private_key is None or str(api_wallet_private_key).startswith(_ENC_PREFIX))
+            and (api_wallet_public_key is None or str(api_wallet_public_key).startswith(_ENC_PREFIX))
+        ):
+            continue
+        conn.execute(
+            """
+            UPDATE accounts
+            SET user_address = ?, api_wallet_private_key = ?, api_wallet_public_key = ?
+            WHERE id = ?
+            """,
+            (
+                _encrypt_value(user_address),
+                _encrypt_optional_value(api_wallet_private_key),
+                _encrypt_optional_value(api_wallet_public_key),
+                row["id"],
+            ),
+        )
+    conn.commit()

hl_cli/infra/paths.py

@@ -0,0 +1,5 @@
+from pathlib import Path
+
+HL_DIR = Path.home() / ".hl"
+DB_PATH = HL_DIR / "hl.db"
+ORDER_CONFIG_PATH = HL_DIR / "order-config.json"

hl_cli/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility helpers."""

hl_cli/utils/market_table.py

@@ -0,0 +1,66 @@
+from typing import Any, Callable
+
+from rich.table import Table
+
+
+def market_table_columns(*, include_category: bool, show_perp_only_fields: bool) -> list[str]:
+    columns = ["Coin", "Pair", "Price", "24h%", "Vol"]
+    if include_category:
+        columns.insert(1, "Category")
+    if show_perp_only_fields:
+        columns.extend(["Funding", "OI"])
+    return columns
+
+
+def market_table_row_values(
+    row: dict[str, Any],
+    *,
+    include_category: bool,
+    show_perp_only_fields: bool,
+    format_price: Callable[[Any], str],
+    format_usd: Callable[[Any], str],
+    format_rate_pct: Callable[[Any], str],
+) -> list[str]:
+    values = [
+        str(row.get("coin", "")),
+        str(row.get("pairName", "")),
+        format_price(row.get("price")),
+        "-" if row.get("priceChange") is None else f"{float(row['priceChange']):.2f}%",
+        format_usd(row.get("volumeUsd")),
+    ]
+    if include_category:
+        values.insert(1, str(row.get("category") or "-"))
+    if show_perp_only_fields:
+        values.extend(
+            [
+                format_rate_pct(row.get("funding")),
+                format_usd(row.get("openInterestUsd")),
+            ]
+        )
+    return values
+
+
+def market_table_widths(columns: list[str], rendered_rows: list[list[str]]) -> list[int]:
+    widths = [len(column) for column in columns]
+    for row in rendered_rows:
+        for idx, value in enumerate(row):
+            widths[idx] = max(widths[idx], len(value))
+    return widths
+
+
+def build_market_table(
+    *,
+    title: str,
+    columns: list[str],
+    rendered_rows: list[list[str]],
+    widths: list[int],
+    highlighted_index: int = -1,
+) -> Table:
+    table = Table(title=title)
+    for idx, column in enumerate(columns):
+        justify = "right" if column in {"Price", "24h%", "Vol", "Funding", "OI"} else "left"
+        table.add_column(column, width=widths[idx], no_wrap=True, overflow="ellipsis", justify=justify)
+    for idx, row in enumerate(rendered_rows):
+        style = "bold reverse" if idx == highlighted_index else ""
+        table.add_row(*row, style=style)
+    return table