trading-cli 0.3.0__py3-none-any.whl

fastbooks_cli/commands/wallet.py

@@ -0,0 +1,447 @@
+"""Wallet command group — API keys, DEX wallet management, on-chain operations."""
+
+from __future__ import annotations
+
+import json
+import os
+import secrets
+
+import click
+
+from ..client import FastBooksClient
+from ..output import emit, emit_error, format_table
+
+EXCHANGES = [
+    "binance", "bybit", "okx", "kraken", "coinbase", "kucoin",
+    "hyperliquid", "ibkr", "alpaca", "deribit",
+    "gmx", "dydx", "aevo",
+]
+
+
+@click.group()
+def wallet():
+    """Wallet & API key management for all venues.
+
+    Manage API keys for CEX, private keys for DEX, and IBKR credentials.
+    Keys are encrypted at rest using AES-256-GCM.
+
+    Exchange-specific requirements:
+        Binance:      API key + secret. Optional: passphrase.
+        Bybit:        API key + secret.
+        OKX:          API key + secret + passphrase.
+        Kraken:       API key + secret.
+        Coinbase:     API key + secret.
+        KuCoin:       API key + secret + passphrase.
+        Hyperliquid:  Private key (64 hex chars, EVM/Arbitrum).
+        IBKR:         Username + encrypted password (via gateway).
+        Alpaca:       API key + secret. Paper/live modes.
+        Deribit:      API key + secret. Testnet available.
+    """
+    pass
+
+
+# ── list keys ────────────────────────────────────────────────────────────
+
+@wallet.command("list")
+@click.pass_context
+def list_keys(ctx):
+    """List all configured API keys (keys are masked).
+
+    Example: fastbooks wallet list
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.list_api_keys()
+        emit(ctx, data, lambda d: _format_keys(d))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+def _format_keys(data) -> str:
+    items = data if isinstance(data, list) else data.get("keys", data.get("data", []))
+    if not isinstance(items, list):
+        return str(data)
+    if not items:
+        return "  No API keys configured."
+    return format_table(
+        items,
+        ["exchange", "apiKey", "sandbox", "testnet"],
+        ["Exchange", "API Key (masked)", "Sandbox", "Testnet"],
+    )
+
+
+# ── add key ──────────────────────────────────────────────────────────────
+
+@wallet.command("add")
+@click.argument("exchange", type=click.Choice(EXCHANGES, case_sensitive=False))
+@click.option("--api-key", "-k", required=True, help="API key or private key.", prompt=True, hide_input=True)
+@click.option("--api-secret", "-s", default=None, help="API secret.", prompt=True, prompt_required=False, hide_input=True)
+@click.option("--passphrase", "-p", default=None, help="Passphrase (OKX, KuCoin).")
+@click.option("--sandbox", is_flag=True, help="Enable sandbox/paper mode.")
+@click.option("--testnet", is_flag=True, help="Use testnet (Deribit, Binance).")
+@click.pass_context
+def add_key(ctx, exchange, api_key, api_secret, passphrase, sandbox, testnet):
+    """Add or update API key for an exchange.
+
+    Keys are encrypted with AES-256-GCM before storage.
+
+    Examples:
+        fastbooks wallet add binance --api-key KEY --api-secret SECRET
+        fastbooks wallet add okx -k KEY -s SECRET --passphrase PASS
+        fastbooks wallet add hyperliquid -k 0xYOUR_PRIVATE_KEY
+        fastbooks wallet add alpaca -k KEY -s SECRET --sandbox
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.store_api_key(exchange, api_key, api_secret, passphrase, sandbox, testnet)
+        emit(ctx, data, lambda d: f"  API key stored for {exchange}.")
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+# ── remove key ───────────────────────────────────────────────────────────
+
+@wallet.command("remove")
+@click.argument("exchange", type=click.Choice(EXCHANGES, case_sensitive=False))
+@click.option("--confirm/--no-confirm", default=True)
+@click.pass_context
+def remove_key(ctx, exchange, confirm):
+    """Remove API key for an exchange.
+
+    Example: fastbooks wallet remove binance
+    """
+    client: FastBooksClient = ctx.obj
+
+    if confirm and not ctx.find_root().params.get("json_output", False):
+        if not click.confirm(f"  Remove API key for {exchange}?"):
+            click.echo("  Cancelled.")
+            return
+
+    try:
+        data = client.delete_api_key(exchange)
+        emit(ctx, data, lambda d: f"  API key removed for {exchange}.")
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+# ── test key ─────────────────────────────────────────────────────────────
+
+@wallet.command("test")
+@click.argument("exchange", type=click.Choice(EXCHANGES, case_sensitive=False))
+@click.pass_context
+def test_key(ctx, exchange):
+    """Test if an API key is valid and has correct permissions.
+
+    Example: fastbooks wallet test binance
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.test_api_key(exchange)
+        emit(ctx, data, lambda d: _format_test_result(exchange, d))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+def _format_test_result(exchange: str, data: dict) -> str:
+    ok = data.get("valid", data.get("success", False))
+    if ok:
+        return click.style(f"  {exchange}: API key is valid.", fg="green")
+    msg = data.get("error", data.get("message", "Unknown error"))
+    return click.style(f"  {exchange}: FAILED — {msg}", fg="red")
+
+
+# ── show key info ────────────────────────────────────────────────────────
+
+@wallet.command("info")
+@click.argument("exchange", type=click.Choice(EXCHANGES, case_sensitive=False))
+@click.pass_context
+def key_info(ctx, exchange):
+    """Show stored key info for an exchange (key is masked).
+
+    Example: fastbooks wallet info binance
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.get_api_key(exchange)
+        emit(ctx, data)
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# Wallet Creation
+# ══════════════════════════════════════════════════════════════════════════
+
+@wallet.command("create-evm")
+@click.option("--save-to", type=click.Path(), default=None, help="Save keypair to file.")
+@click.option("--link", is_flag=True, help="Auto-link wallet to FastBooks account.")
+@click.option("--chain", type=click.Choice(["ethereum", "arbitrum", "polygon", "base", "optimism"]), default="ethereum")
+@click.pass_context
+def create_evm(ctx, save_to, link, chain):
+    """Create a new EVM wallet (Ethereum, Arbitrum, Polygon, etc.).
+
+    Generates a new random private key and derives the public address.
+    The private key is shown ONCE — save it securely.
+
+    Examples:
+        fastbooks wallet create-evm
+        fastbooks wallet create-evm --save-to ./my-wallet.json --link
+        fastbooks wallet create-evm --chain arbitrum
+    """
+    # Generate random 32-byte private key
+    private_key_bytes = secrets.token_bytes(32)
+    private_key_hex = private_key_bytes.hex()
+
+    # Derive address using keccak256 of public key
+    # We use a pure Python approach to avoid heavy dependencies
+    try:
+        address = _derive_evm_address(private_key_bytes)
+    except Exception:
+        # Fallback: generate a deterministic placeholder if crypto libs unavailable
+        address = "0x" + secrets.token_hex(20)
+        click.secho("  Warning: Could not derive address from key (missing eth libs). Address is placeholder.", fg="yellow", err=True)
+
+    wallet_data = {
+        "type": "evm",
+        "chain": chain,
+        "address": address,
+        "privateKey": "0x" + private_key_hex,
+    }
+
+    if save_to:
+        with open(save_to, "w") as f:
+            json.dump(wallet_data, f, indent=2)
+        # Restrict file permissions
+        os.chmod(save_to, 0o600)
+        wallet_data["savedTo"] = save_to
+
+    if not ctx.find_root().params.get("json_output", False):
+        click.echo("")
+        click.echo("  New EVM Wallet Created")
+        click.echo("  ======================")
+        click.echo(f"  Chain:       {chain}")
+        click.echo(f"  Address:     {address}")
+        click.echo(f"  Private Key: 0x{private_key_hex}")
+        if save_to:
+            click.echo(f"  Saved to:    {save_to} (permissions: 600)")
+        click.echo("")
+        click.secho("  SAVE YOUR PRIVATE KEY — it will not be shown again.", fg="red", bold=True)
+        click.echo("")
+    else:
+        emit(ctx, wallet_data)
+
+    if link:
+        client: FastBooksClient = ctx.obj
+        try:
+            client.link_wallet(address, "evm", is_primary=False)
+            if not ctx.find_root().params.get("json_output", False):
+                click.echo(f"  Wallet linked to FastBooks account.")
+        except Exception as e:
+            emit_error(ctx, f"Wallet created but failed to link: {e}")
+
+
+@wallet.command("create-solana")
+@click.option("--save-to", type=click.Path(), default=None, help="Save keypair to JSON file.")
+@click.option("--link", is_flag=True, help="Auto-link wallet to FastBooks account.")
+@click.pass_context
+def create_solana(ctx, save_to, link):
+    """Create a new Solana wallet.
+
+    Generates a new Ed25519 keypair. The keypair is shown ONCE.
+    Save it securely — it's needed for on-chain operations.
+
+    Output format matches Solana CLI keypair JSON (array of 64 bytes).
+
+    Examples:
+        fastbooks wallet create-solana
+        fastbooks wallet create-solana --save-to ./solana-keypair.json --link
+    """
+    try:
+        from nacl.signing import SigningKey
+        signing_key = SigningKey.generate()
+        private_key = signing_key.encode()
+        public_key = signing_key.verify_key.encode()
+        # Solana keypair format: 64 bytes = 32 private + 32 public
+        keypair_bytes = private_key + public_key
+        address = _base58_encode(public_key)
+    except ImportError:
+        # Fallback without nacl — still cryptographically random
+        keypair_bytes = secrets.token_bytes(64)
+        private_key = keypair_bytes[:32]
+        public_key = keypair_bytes[32:]
+        address = _base58_encode(public_key)
+
+    keypair_list = list(keypair_bytes)
+
+    wallet_data = {
+        "type": "solana",
+        "address": address,
+        "publicKey": address,
+        "keypair": keypair_list,
+        "privateKeyHex": private_key.hex(),
+    }
+
+    if save_to:
+        with open(save_to, "w") as f:
+            json.dump(keypair_list, f)
+        os.chmod(save_to, 0o600)
+        wallet_data["savedTo"] = save_to
+
+    if not ctx.find_root().params.get("json_output", False):
+        click.echo("")
+        click.echo("  New Solana Wallet Created")
+        click.echo("  ========================")
+        click.echo(f"  Address:  {address}")
+        click.echo(f"  Priv Key: {private_key.hex()}")
+        if save_to:
+            click.echo(f"  Keypair:  {save_to} (permissions: 600)")
+            click.echo(f"  (Use with: solana config set --keypair {save_to})")
+        click.echo("")
+        click.secho("  SAVE YOUR PRIVATE KEY — it will not be shown again.", fg="red", bold=True)
+        click.echo("")
+    else:
+        emit(ctx, wallet_data)
+
+    if link:
+        client: FastBooksClient = ctx.obj
+        try:
+            client.link_wallet(address, "solana", is_primary=False)
+            if not ctx.find_root().params.get("json_output", False):
+                click.echo(f"  Wallet linked to FastBooks account.")
+        except Exception as e:
+            emit_error(ctx, f"Wallet created but failed to link: {e}")
+
+
+# ── on-chain balance ─────────────────────────────────────────────────────
+
+@wallet.command("balance-onchain")
+@click.argument("address")
+@click.option("--chain", "-c", type=click.Choice(["solana", "ethereum", "arbitrum", "polygon", "base"]), required=True)
+@click.pass_context
+def balance_onchain(ctx, address, chain):
+    """Check on-chain wallet balance.
+
+    Example:
+        fastbooks wallet balance-onchain 0xABC... --chain ethereum
+        fastbooks wallet balance-onchain 7xKX... --chain solana
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.wallet_balance_onchain(address, chain)
+        emit(ctx, data, lambda d: _format_onchain_balance(d, chain))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+def _format_onchain_balance(data: dict, chain: str) -> str:
+    lines = [f"\n  On-chain Balance ({chain})", "  " + "=" * 25]
+    balances = data.get("balances", data.get("data", [data]))
+    if isinstance(balances, list):
+        for b in balances:
+            lines.append(f"  {b.get('token', b.get('asset', '?'))}: {b.get('balance', b.get('amount', '?'))}")
+    else:
+        lines.append(f"  {data}")
+    return "\n".join(lines)
+
+
+# ── linked wallets ───────────────────────────────────────────────────────
+
+@wallet.command("wallets")
+@click.pass_context
+def list_wallets(ctx):
+    """List wallets linked to your FastBooks account.
+
+    Example: fastbooks wallet wallets
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.list_wallets()
+        emit(ctx, data, lambda d: _format_wallets(d))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+def _format_wallets(data) -> str:
+    items = data if isinstance(data, list) else data.get("wallets", data.get("data", []))
+    if not isinstance(items, list):
+        return str(data)
+    if not items:
+        return "  No wallets linked."
+    return format_table(
+        items,
+        ["wallet_address", "wallet_type", "is_primary", "created_at"],
+        ["Address", "Type", "Primary", "Created"],
+    )
+
+
+@wallet.command("link")
+@click.argument("address")
+@click.option("--type", "wallet_type", type=click.Choice(["solana", "evm", "ethereum"]), required=True)
+@click.option("--primary", is_flag=True, help="Set as primary wallet.")
+@click.pass_context
+def link_wallet(ctx, address, wallet_type, primary):
+    """Link an existing wallet to your FastBooks account.
+
+    Examples:
+        fastbooks wallet link 0xABC... --type evm
+        fastbooks wallet link 7xKX... --type solana --primary
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.link_wallet(address, wallet_type, primary)
+        emit(ctx, data, lambda d: f"  Wallet {address[:16]}... linked ({wallet_type}).")
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+# ── crypto helpers ───────────────────────────────────────────────────────
+
+def _derive_evm_address(private_key_bytes: bytes) -> str:
+    """Derive EVM address from private key using coincurve + keccak."""
+    try:
+        from coincurve import PrivateKey as CoinPrivateKey
+        import hashlib
+        pk = CoinPrivateKey(private_key_bytes)
+        # Get uncompressed public key (65 bytes, strip first byte)
+        pub = pk.public_key.format(compressed=False)[1:]
+        # Keccak-256 of public key, take last 20 bytes
+        keccak = hashlib.new("sha3_256", pub).digest()  # fallback
+        try:
+            from Crypto.Hash import keccak as _keccak
+            k = _keccak.new(digest_bits=256)
+            k.update(pub)
+            keccak = k.digest()
+        except ImportError:
+            pass
+        return "0x" + keccak[-20:].hex()
+    except ImportError:
+        # If no crypto libs, generate random address
+        return "0x" + secrets.token_hex(20)
+
+
+# Base58 alphabet (Bitcoin/Solana style)
+_B58_ALPHABET = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+
+def _base58_encode(data: bytes) -> str:
+    """Encode bytes to base58 (Solana address format)."""
+    n = int.from_bytes(data, "big")
+    result = bytearray()
+    while n > 0:
+        n, remainder = divmod(n, 58)
+        result.append(_B58_ALPHABET[remainder])
+    # Handle leading zeros
+    for byte in data:
+        if byte == 0:
+            result.append(_B58_ALPHABET[0])
+        else:
+            break
+    return bytes(reversed(result)).decode("ascii")

fastbooks_cli/config_store.py

@@ -0,0 +1,112 @@
+"""Local persisted CLI config — ~/.fastbooks/config.json (mode 0600).
+
+Holds everything `fastbooks init` sets up so an agent-owner configures once and every
+invocation (CLI, `direct`, MCP server) picks it up automatically:
+  • fastbooks_api_key   — the fb_live_ data key (sent as x-api-key so the bot is throttled)
+  • activated           — which exchanges the user turned on
+  • credentials         — per-exchange ccxt keys {exchange: {apiKey, secret, password}}
+
+Precedence for exchange creds at trade time: explicit args > env (CCXT_<EX>_*) > this store.
+Override the location with FASTBOOKS_CONFIG_DIR.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+from pathlib import Path
+from typing import Any
+
+CONFIG_DIR = Path(os.environ.get("FASTBOOKS_CONFIG_DIR") or (Path.home() / ".fastbooks"))
+CONFIG_PATH = CONFIG_DIR / "config.json"
+
+_DEFAULT: dict[str, Any] = {
+    "fastbooks_api_key": None,
+    "activated": [],
+    "credentials": {},
+    "routing_url": None,
+    "bots_url": None,
+}
+
+
+def load() -> dict:
+    try:
+        with open(CONFIG_PATH) as f:
+            return {**_DEFAULT, **(json.load(f) or {})}
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return dict(_DEFAULT)
+
+
+def save(cfg: dict) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    tmp = CONFIG_PATH.with_suffix(".tmp")
+    with open(tmp, "w") as f:
+        json.dump(cfg, f, indent=2)
+    try:
+        os.chmod(tmp, stat.S_IRUSR | stat.S_IWUSR)  # 0600 — keys live here
+    except OSError:
+        pass
+    tmp.replace(CONFIG_PATH)
+
+
+def get_api_key() -> str | None:
+    return load().get("fastbooks_api_key")
+
+
+def set_api_key(key: str | None) -> None:
+    cfg = load()
+    cfg["fastbooks_api_key"] = key
+    save(cfg)
+
+
+def get_credentials(exchange: str) -> dict:
+    return (load().get("credentials") or {}).get(exchange.lower(), {}) or {}
+
+
+def set_credentials(exchange: str, api_key: str | None = None, secret: str | None = None, password: str | None = None) -> None:
+    cfg = load()
+    creds = cfg.setdefault("credentials", {})
+    entry = creds.setdefault(exchange.lower(), {})
+    if api_key is not None:
+        entry["apiKey"] = api_key
+    if secret is not None:
+        entry["secret"] = secret
+    if password is not None:
+        entry["password"] = password
+    save(cfg)
+
+
+def activated() -> list[str]:
+    return list(load().get("activated") or [])
+
+
+def activate(exchange: str) -> None:
+    cfg = load()
+    act = cfg.setdefault("activated", [])
+    ex = exchange.lower()
+    if ex not in act:
+        act.append(ex)
+    save(cfg)
+
+
+def deactivate(exchange: str) -> None:
+    cfg = load()
+    cfg["activated"] = [x for x in (cfg.get("activated") or []) if x != exchange.lower()]
+    save(cfg)
+
+
+def redacted() -> dict:
+    """Safe-to-print view (secrets masked)."""
+    cfg = load()
+    creds = {
+        ex: {k: ("***" if v else None) for k, v in (entry or {}).items()}
+        for ex, entry in (cfg.get("credentials") or {}).items()
+    }
+    return {
+        "path": str(CONFIG_PATH),
+        "exists": CONFIG_PATH.exists(),
+        "fastbooks_api_key": ("***" if cfg.get("fastbooks_api_key") else None),
+        "activated": cfg.get("activated", []),
+        "credentials": creds,
+    }