trading-cli 0.3.0__py3-none-any.whl

fastbooks_cli/client.py

@@ -0,0 +1,1169 @@
+"""HTTP client for FastBooks API services."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from typing import Any
+
+import requests
+
+DEFAULT_ROUTING_URL = "http://localhost:3002"
+DEFAULT_BOTS_URL = "http://localhost:8003"
+
+
+def _stored_api_key() -> str | None:
+    """FastBooks data key persisted by `fastbooks init` (falls back after env)."""
+    try:
+        from . import config_store
+        return config_store.get_api_key()
+    except Exception:
+        return None
+
+
+class FastBooksClient:
+    """Thin wrapper around the FastBooks REST APIs."""
+
+    def __init__(
+        self,
+        routing_url: str | None = None,
+        bots_url: str | None = None,
+        timeout: int = 30,
+        token: str | None = None,
+        api_key: str | None = None,
+    ):
+        self.routing_url = (
+            routing_url or os.environ.get("FASTBOOKS_ROUTING_URL", DEFAULT_ROUTING_URL)
+        ).rstrip("/")
+        self.bots_url = (
+            bots_url or os.environ.get("FASTBOOKS_BOTS_URL", DEFAULT_BOTS_URL)
+        ).rstrip("/")
+        self.timeout = timeout
+        # JWT access token for authenticated routes (api-keys, saved backtests).
+        # Sent as `Authorization: Bearer <token>` on every request when present.
+        self.token = token or os.environ.get("FASTBOOKS_API_TOKEN") or None
+        # FastBooks PUBLIC-API key (fb_live_...). Sent as `x-api-key` on every request so the
+        # platform meters/throttles this bot's data usage per key. Mint one, free & self-service,
+        # with `fastbooks apikey create`. Keyless still works for the frontend, but bots should key.
+        self.api_key = api_key or os.environ.get("FASTBOOKS_API_KEY") or _stored_api_key()
+        self._session = requests.Session()
+        if self.token:
+            self._session.headers["Authorization"] = f"Bearer {self.token}"
+        if self.api_key:
+            self._session.headers["x-api-key"] = self.api_key
+
+    # ── helpers ──────────────────────────────────────────────────────
+
+    def _get(self, base: str, path: str, params: dict | None = None, headers: dict | None = None) -> Any:
+        url = f"{base}{path}"
+        r = self._session.get(url, params=params, headers=headers, timeout=self.timeout)
+        r.raise_for_status()
+        return r.json()
+
+    def _post(self, base: str, path: str, data: dict | None = None, headers: dict | None = None) -> Any:
+        url = f"{base}{path}"
+        r = self._session.post(url, json=data, headers=headers, timeout=self.timeout)
+        r.raise_for_status()
+        return r.json()
+
+    def _patch(self, base: str, path: str, data: dict | None = None) -> Any:
+        url = f"{base}{path}"
+        r = self._session.patch(url, json=data, timeout=self.timeout)
+        r.raise_for_status()
+        return r.json()
+
+    def _delete(self, base: str, path: str, params: dict | None = None) -> Any:
+        url = f"{base}{path}"
+        r = self._session.delete(url, params=params, timeout=self.timeout)
+        r.raise_for_status()
+        return r.json()
+
+    # ── markets ──────────────────────────────────────────────────────
+
+    def orderbook(self, exchange: str, symbol: str) -> dict:
+        return self._get(self.routing_url, "/api/markets/orderbooks", {"exchange": exchange, "symbol": symbol})
+
+    def orderbooks_aggregated(self, category: str = "all") -> dict:
+        return self._get(self.routing_url, "/api/markets/orderbooks/aggregated", {"category": category})
+
+    def tickers(
+        self,
+        page: int = 1,
+        limit: int = 50,
+        category: str | None = None,
+        exchange: str | None = None,
+        search: str | None = None,
+    ) -> dict:
+        params: dict[str, Any] = {"page": page, "limit": limit}
+        if category:
+            params["category"] = category
+        if exchange:
+            params["exchange"] = exchange
+        if search:
+            params["search"] = search
+        return self._get(self.routing_url, "/api/markets/tickers/all", params)
+
+    def ohlcv(
+        self,
+        exchange: str,
+        symbol: str,
+        timeframe: str = "1h",
+        limit: int = 300,
+    ) -> dict:
+        return self._get(
+            self.routing_url,
+            "/api/markets/ohlcv",
+            {"exchange": exchange, "symbol": symbol, "timeframe": timeframe, "limit": limit},
+        )
+
+    def symbols_universe(
+        self,
+        region: str = "us",
+        sector: str | None = None,
+        limit: int = 100,
+    ) -> dict:
+        params: dict[str, Any] = {"region": region, "limit": limit}
+        if sector:
+            params["sector"] = sector
+        return self._get(self.routing_url, "/api/markets/symbols/universe", params)
+
+    def symbols_summary(self, symbols: list[str], fields: str | None = None) -> dict:
+        params: dict[str, Any] = {"symbols": ",".join(symbols)}
+        if fields:
+            params["fields"] = fields
+        return self._get(self.routing_url, "/api/markets/symbols/summary", params)
+
+    def options_chain(self, underlying: str) -> dict:
+        return self._get(self.routing_url, "/api/markets/options/chain", {"underlying": underlying})
+
+    # ── execution ────────────────────────────────────────────────────
+
+    def place_order(
+        self,
+        venue: str,
+        symbol: str,
+        side: str,
+        order_type: str,
+        amount: float,
+        price: float | None = None,
+        client_order_id: str | None = None,
+    ) -> dict:
+        body: dict[str, Any] = {
+            "venue": venue,
+            "symbol": symbol,
+            "side": side,
+            "type": order_type,
+            "amount": amount,
+        }
+        if price is not None:
+            body["price"] = price
+        if client_order_id:
+            body["clientOrderId"] = client_order_id
+        return self._post(self.routing_url, "/api/execution/orders", body)
+
+    def cancel_order(self, venue: str, order_id: str, symbol: str | None = None) -> dict:
+        params: dict[str, Any] = {"venue": venue}
+        if symbol:
+            params["symbol"] = symbol
+        return self._delete(self.routing_url, f"/api/execution/orders/{order_id}", params)
+
+    def list_orders(self, venue: str, symbol: str | None = None) -> dict:
+        params: dict[str, Any] = {"venue": venue}
+        if symbol:
+            params["symbol"] = symbol
+        return self._get(self.routing_url, "/api/execution/orders", params)
+
+    def get_order(self, venue: str, order_id: str, symbol: str | None = None) -> dict:
+        params: dict[str, Any] = {"venue": venue}
+        if symbol:
+            params["symbol"] = symbol
+        return self._get(self.routing_url, f"/api/execution/orders/{order_id}", params)
+
+    def order_history(self, venue: str = "ibkr") -> dict:
+        return self._get(self.routing_url, "/api/execution/orders/history", {"venue": venue})
+
+    def balance(self, venue: str, asset: str | None = None) -> dict:
+        params: dict[str, Any] = {"venue": venue}
+        if asset:
+            params["asset"] = asset
+        return self._get(self.routing_url, "/api/execution/balance", params)
+
+    def positions(self, venue: str) -> dict:
+        return self._get(self.routing_url, "/api/execution/positions", {"venue": venue})
+
+    def update_leverage(
+        self,
+        venue: str,
+        symbol: str,
+        leverage: int,
+        is_cross: bool = False,
+    ) -> dict:
+        return self._post(
+            self.routing_url,
+            "/api/execution/leverage",
+            {"venue": venue, "symbol": symbol, "leverage": leverage, "isCross": is_cross},
+        )
+
+    def venues(self) -> dict:
+        return self._get(self.routing_url, "/api/execution/venues", None)
+
+    def quote(self, venue: str, symbol: str) -> dict:
+        return self._get(self.routing_url, "/api/execution/quote", {"venue": venue, "symbol": symbol})
+
+    def paper_init(self, balance: float | None = None, venue: str | None = None) -> dict:
+        body: dict[str, Any] = {}
+        if balance is not None:
+            body["balance"] = balance
+        if venue:
+            body["venue"] = venue
+        return self._post(self.routing_url, "/api/execution/paper/init", body)
+
+    # ── alpha dashboard (/api/alpha) ─────────────────────────────────
+
+    def alpha_health(self) -> dict:
+        return self._get(self.routing_url, "/api/alpha/health", None)
+
+    def alpha_summary(self, market: str = "us") -> dict:
+        return self._get(self.routing_url, "/api/alpha/summary", {"market": market})
+
+    def alpha_movers(self, kind: str, limit: int = 20, market: str = "us") -> dict:
+        # kind: gainers | losers | breakouts | volume-alerts | news | snapshots
+        return self._get(self.routing_url, f"/api/alpha/{kind}", {"limit": limit, "market": market})
+
+    # ── market regime overlay (/api/regime) ──────────────────────────
+
+    def regime_health(self) -> dict:
+        return self._get(self.routing_url, "/api/regime/health", None)
+
+    def regime_summary(self, date: str | None = None) -> dict:
+        params = {"date": date} if date else None
+        return self._get(self.routing_url, "/api/regime/summary", params)
+
+    def regime_dates(self) -> dict:
+        return self._get(self.routing_url, "/api/regime/dates", None)
+
+    # ── AI analyst (/api/analyst) ────────────────────────────────────
+
+    def analyst_health(self) -> dict:
+        return self._get(self.routing_url, "/api/analyst/health", None)
+
+    def analyst_analyze(self, analysis_type: str, query: str, symbol: str | None = None) -> dict:
+        body: dict[str, Any] = {"analysis_type": analysis_type, "query": query}
+        if symbol:
+            body["symbol"] = symbol
+        return self._post(self.routing_url, "/api/analyst/analyze", body)
+
+    # ── api keys ─────────────────────────────────────────────────────
+    # NOTE: these live under /api/markets/api-keys and require a JWT
+    # (pass --token / FASTBOOKS_API_TOKEN). They are NOT at /api/api-keys.
+
+    def list_api_keys(self) -> dict:
+        return self._get(self.routing_url, "/api/markets/api-keys", None)
+
+    def get_api_key(self, exchange: str) -> dict:
+        return self._get(self.routing_url, f"/api/markets/api-keys/{exchange}", None)
+
+    def store_api_key(
+        self,
+        exchange: str,
+        api_key: str,
+        api_secret: str | None = None,
+        passphrase: str | None = None,
+        sandbox: bool = False,
+        testnet: bool = False,
+    ) -> dict:
+        body: dict[str, Any] = {"exchange": exchange, "apiKey": api_key}
+        if api_secret:
+            body["apiSecret"] = api_secret
+        if passphrase:
+            body["passphrase"] = passphrase
+        if sandbox:
+            body["sandbox"] = True
+        if testnet:
+            body["testnet"] = True
+        return self._post(self.routing_url, "/api/markets/api-keys", body)
+
+    def delete_api_key(self, exchange: str) -> dict:
+        return self._delete(self.routing_url, f"/api/markets/api-keys/{exchange}")
+
+    def test_api_key(self, exchange: str) -> dict:
+        return self._post(self.routing_url, f"/api/markets/api-keys/{exchange}/test")
+
+    # ── FastBooks platform API keys (fully self-service, no admin token) ──
+    # These authenticate the FastBooks PUBLIC API (/api/public/v1). Any human
+    # or agent can mint a free, read-only key rate-limited to 5 req/sec, then
+    # inspect or revoke it by presenting the key itself (proof of ownership).
+
+    def create_fastbooks_api_key(
+        self,
+        label: str,
+        user_id: str | None = None,
+        email: str | None = None,
+    ) -> dict:
+        body: dict[str, Any] = {"label": label}
+        if user_id:
+            body["userId"] = user_id
+        if email:
+            body["email"] = email
+        return self._post(self.routing_url, "/api/keys", body)
+
+    def fastbooks_api_key_limits(self) -> dict:
+        return self._get(self.routing_url, "/api/keys/limits", None)
+
+    # ── on-chain (FastBots engine via /api/onchain proxy) ─────────────
+    # The proxy is auth+email-gated: needs --token (a JWT) whose email is on the
+    # engine allowlist. Paths map to the isolated solana-trading-bots engine.
+
+    def onchain_get(self, engine_path: str, params: dict | None = None) -> Any:
+        return self._get(self.routing_url, f"/api/onchain{engine_path}", params)
+
+    def onchain_post(self, engine_path: str, data: dict | None = None) -> Any:
+        return self._post(self.routing_url, f"/api/onchain{engine_path}", data)
+
+    def onchain_live_status(self) -> Any:
+        return self.onchain_get("/api/exec/live/status")
+
+    def onchain_stats(self, by_bot: bool = False) -> Any:
+        return self.onchain_get("/api/exec/stats/by-bot" if by_bot else "/api/exec/stats")
+
+    def onchain_strategies(self) -> Any:
+        return self.onchain_get("/api/exec/strategies")
+
+    def onchain_positions(self, status: str | None = None) -> Any:
+        return self.onchain_get("/api/exec/positions", {"status": status} if status else None)
+
+    def onchain_trades(self, limit: int = 40) -> Any:
+        return self.onchain_get("/api/exec/trades", {"limit": limit})
+
+    def onchain_live_start(self, strategy_id: str, opts: dict | None = None) -> Any:
+        return self.onchain_post("/api/exec/live/start", {"strategyId": strategy_id, "opts": opts or {}})
+
+    def onchain_live_stop(self, strategy_id: str) -> Any:
+        return self.onchain_post("/api/exec/live/stop", {"strategyId": strategy_id})
+
+    def fastbooks_api_key_info(self, api_key: str) -> dict:
+        return self._get(self.routing_url, "/api/keys/me", headers={"x-api-key": api_key})
+
+    def revoke_fastbooks_api_key(self, api_key: str) -> dict:
+        return self._post(self.routing_url, "/api/keys/revoke", {"apiKey": api_key})
+
+    # ── FastBooks public API (/api/public/v1, x-api-key) ─────────────
+
+    def public_markets(
+        self,
+        api_key: str,
+        category: str | None = None,
+        exchange: str | None = None,
+        search: str | None = None,
+        country: str | None = None,
+    ) -> dict:
+        params: dict[str, Any] = {}
+        if category:
+            params["category"] = category
+        if exchange:
+            params["exchange"] = exchange
+        if search:
+            params["search"] = search
+        if country:
+            params["country"] = country
+        return self._get(self.routing_url, "/api/public/v1/markets", params, headers={"x-api-key": api_key})
+
+    def public_market_get(self, api_key: str, market_id: str) -> dict:
+        return self._get(self.routing_url, f"/api/public/v1/markets/{market_id}", headers={"x-api-key": api_key})
+
+    def public_markets_summary(self, api_key: str) -> dict:
+        return self._get(self.routing_url, "/api/public/v1/stats/markets/summary", headers={"x-api-key": api_key})
+
+    # ── bots ─────────────────────────────────────────────────────────
+
+    def create_bot(self, config: dict) -> dict:
+        return self._post(self.bots_url, "/bots", config)
+
+    def list_bots(self, investor_id: str | None = None) -> dict:
+        params = {"investor_id": investor_id} if investor_id else None
+        return self._get(self.bots_url, "/bots", params)
+
+    def get_bot(self, bot_id: str) -> dict:
+        return self._get(self.bots_url, f"/bots/{bot_id}", None)
+
+    def update_bot(self, bot_id: str, updates: dict) -> dict:
+        return self._patch(self.bots_url, f"/bots/{bot_id}", updates)
+
+    def delete_bot(self, bot_id: str) -> dict:
+        return self._delete(self.bots_url, f"/bots/{bot_id}")
+
+    def start_bot(self, bot_id: str) -> dict:
+        return self._post(self.bots_url, f"/bots/{bot_id}/start")
+
+    def stop_bot(self, bot_id: str) -> dict:
+        return self._post(self.bots_url, f"/bots/{bot_id}/stop")
+
+    def pause_bot(self, bot_id: str) -> dict:
+        return self._post(self.bots_url, f"/bots/{bot_id}/pause")
+
+    def resume_bot(self, bot_id: str) -> dict:
+        return self._post(self.bots_url, f"/bots/{bot_id}/resume")
+
+    def bot_events(self, bot_id: str, limit: int = 50) -> dict:
+        return self._get(self.bots_url, f"/bots/{bot_id}/events", {"limit": limit})
+
+    def bot_logs(self, bot_id: str, since: int = 0) -> dict:
+        return self._get(self.bots_url, f"/bots/{bot_id}/logs", {"since": since})
+
+    def bot_report(self, bot_id: str) -> dict:
+        return self._get(self.bots_url, f"/bots/{bot_id}/report", None)
+
+    def rebalance_bot(self, bot_id: str) -> dict:
+        return self._post(self.bots_url, f"/bots/{bot_id}/rebalance")
+
+    def bot_trade(self, bot_id: str, intent: dict) -> dict:
+        return self._post(self.bots_url, f"/bots/{bot_id}/trade", intent)
+
+    def deploy_bot(self, config: dict) -> dict:
+        """Deploy a bot from a marketplace/template definition (newer path)."""
+        return self._post(self.bots_url, "/bots/deploy", config)
+
+    def bot_command(self, bot_id: str, command: str, args: dict | None = None) -> dict:
+        body: dict[str, Any] = {"command": command}
+        if args:
+            body["args"] = args
+        return self._post(self.bots_url, f"/bots/{bot_id}/command", body)
+
+    def all_events(self, limit: int = 50) -> dict:
+        return self._get(self.bots_url, "/events", {"limit": limit})
+
+    def emergency_stop_all(self) -> dict:
+        return self._post(self.bots_url, "/emergency/stop-all")
+
+    def backtest_report(self, payload: dict) -> dict:
+        return self._post(self.bots_url, "/bots/backtest-report", payload)
+
+    # ── backtesting ──────────────────────────────────────────────────
+
+    def run_backtest(self, config: dict) -> dict:
+        return self._post(self.bots_url, "/bots/crypto-backtest", config)
+
+    def forward_test(self, config: dict) -> dict:
+        return self._post(self.bots_url, "/bots/forward-test", config)
+
+    def list_backtests(self) -> dict:
+        return self._get(self.routing_url, "/api/markets/bots/backtests", None)
+
+    def delete_backtest(self, backtest_id: str) -> dict:
+        return self._delete(self.routing_url, f"/api/markets/bots/backtests/{backtest_id}")
+
+    # ── DEX ──────────────────────────────────────────────────────────
+
+    def dex_tickers(self) -> dict:
+        return self._get(self.routing_url, "/api/markets/tickers/all", {"category": "dex"})
+
+    # ── prediction markets ───────────────────────────────────────────
+
+    def polymarket_search(self, query: str, limit: int = 20) -> dict:
+        return self._get(
+            self.routing_url,
+            "/api/markets/orderbooks",
+            {"exchange": "polymarket", "symbol": query},
+        )
+
+    def limitless_market(self, slug: str) -> dict:
+        return self._get(
+            self.routing_url,
+            "/api/markets/orderbooks",
+            {"exchange": "limitless", "symbol": slug},
+        )
+
+    # ── Polymarket — markets & events ───────────────────────────────
+
+    def polymarket_markets_list(
+        self, limit: int = 20, offset: int = 0, active: bool | None = None,
+        closed: bool | None = None, order: str | None = None, ascending: bool = False,
+    ) -> dict:
+        params: dict[str, Any] = {"limit": limit, "offset": offset}
+        if active is not None:
+            params["active"] = active
+        if closed is not None:
+            params["closed"] = closed
+        if order:
+            params["order"] = order
+        if ascending:
+            params["ascending"] = True
+        return self._get(self.routing_url, "/api/polymarket/markets", params)
+
+    def polymarket_market_get(self, id_or_slug: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/markets/{id_or_slug}")
+
+    def polymarket_market_search(self, query: str, limit: int = 10) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/markets/search", {"q": query, "limit": limit})
+
+    def polymarket_events_list(
+        self, limit: int = 20, offset: int = 0, tag: str | None = None,
+        active: bool | None = None, closed: bool | None = None,
+    ) -> dict:
+        params: dict[str, Any] = {"limit": limit, "offset": offset}
+        if tag:
+            params["tag"] = tag
+        if active is not None:
+            params["active"] = active
+        if closed is not None:
+            params["closed"] = closed
+        return self._get(self.routing_url, "/api/polymarket/events", params)
+
+    def polymarket_event_get(self, event_id: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/events/{event_id}")
+
+    def polymarket_tags_list(self) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/tags")
+
+    # ── Polymarket — CLOB (order book, prices) ─────────────────────
+
+    def polymarket_clob_book(self, token_id: str) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/book", {"token": token_id})
+
+    def polymarket_clob_price(self, token_id: str, side: str = "buy") -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/price", {"token": token_id, "side": side})
+
+    def polymarket_clob_midpoint(self, token_id: str) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/midpoint", {"token": token_id})
+
+    def polymarket_clob_spread(self, token_id: str) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/spread", {"token": token_id})
+
+    def polymarket_clob_last_trade(self, token_id: str) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/last-trade", {"token": token_id})
+
+    def polymarket_clob_price_history(
+        self, token_id: str, interval: str = "1d", fidelity: int = 30,
+    ) -> dict:
+        return self._get(
+            self.routing_url, "/api/polymarket/clob/price-history",
+            {"token": token_id, "interval": interval, "fidelity": fidelity},
+        )
+
+    def polymarket_clob_markets(self) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/markets")
+
+    def polymarket_clob_market(self, condition_id: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/clob/markets/{condition_id}")
+
+    # ── Polymarket — trading (authenticated) ───────────────────────
+
+    def polymarket_create_order(
+        self, token_id: str, side: str, price: float, size: float,
+        order_type: str = "GTC", private_key: str | None = None,
+    ) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/clob/order",
+            {
+                "token": token_id, "side": side, "price": price,
+                "size": size, "orderType": order_type,
+                "privateKey": private_key,
+            },
+        )
+
+    def polymarket_market_order(
+        self, token_id: str, side: str, amount: float,
+        private_key: str | None = None,
+    ) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/clob/market-order",
+            {"token": token_id, "side": side, "amount": amount, "privateKey": private_key},
+        )
+
+    def polymarket_cancel_order(self, order_id: str, private_key: str | None = None) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/clob/cancel",
+            {"orderId": order_id, "privateKey": private_key},
+        )
+
+    def polymarket_cancel_all(self, private_key: str | None = None) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/clob/cancel-all",
+            {"privateKey": private_key},
+        )
+
+    def polymarket_cancel_market(self, condition_id: str, private_key: str | None = None) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/clob/cancel-market",
+            {"market": condition_id, "privateKey": private_key},
+        )
+
+    # ── Polymarket — account queries (authenticated) ───────────────
+
+    def polymarket_orders(self, market: str | None = None, private_key: str | None = None) -> dict:
+        params: dict[str, Any] = {}
+        if market:
+            params["market"] = market
+        if private_key:
+            params["privateKey"] = private_key
+        return self._get(self.routing_url, "/api/polymarket/clob/orders", params)
+
+    def polymarket_trades(self, private_key: str | None = None) -> dict:
+        params: dict[str, Any] = {}
+        if private_key:
+            params["privateKey"] = private_key
+        return self._get(self.routing_url, "/api/polymarket/clob/trades", params)
+
+    def polymarket_balance(self, asset_type: str = "collateral", token_id: str | None = None, private_key: str | None = None) -> dict:
+        params: dict[str, Any] = {"assetType": asset_type}
+        if token_id:
+            params["token"] = token_id
+        if private_key:
+            params["privateKey"] = private_key
+        return self._get(self.routing_url, "/api/polymarket/clob/balance", params)
+
+    # ── Polymarket — on-chain data (public) ────────────────────────
+
+    def polymarket_data_positions(self, address: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/data/positions/{address}")
+
+    def polymarket_data_value(self, address: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/data/value/{address}")
+
+    def polymarket_data_trades(self, address: str, limit: int = 50) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/data/trades/{address}", {"limit": limit})
+
+    def polymarket_data_leaderboard(self, period: str = "month", order_by: str = "pnl", limit: int = 20) -> dict:
+        return self._get(
+            self.routing_url, "/api/polymarket/data/leaderboard",
+            {"period": period, "orderBy": order_by, "limit": limit},
+        )
+
+    # ── Polymarket — CTF operations (on-chain, authenticated) ──────
+
+    def polymarket_ctf_split(self, condition_id: str, amount: float, private_key: str | None = None) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/ctf/split",
+            {"condition": condition_id, "amount": amount, "privateKey": private_key},
+        )
+
+    def polymarket_ctf_merge(self, condition_id: str, amount: float, private_key: str | None = None) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/ctf/merge",
+            {"condition": condition_id, "amount": amount, "privateKey": private_key},
+        )
+
+    def polymarket_ctf_redeem(self, condition_id: str, private_key: str | None = None) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/ctf/redeem",
+            {"condition": condition_id, "privateKey": private_key},
+        )
+
+    # ── Polymarket — approvals ─────────────────────────────────────
+
+    def polymarket_approve_check(self, address: str | None = None) -> dict:
+        params = {"address": address} if address else None
+        return self._get(self.routing_url, "/api/polymarket/approve/check", params)
+
+    def polymarket_approve_set(self, private_key: str | None = None) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/approve/set",
+            {"privateKey": private_key},
+        )
+
+    # ── Polymarket — bridge ────────────────────────────────────────
+
+    def polymarket_bridge_deposit(self, address: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/bridge/deposit/{address}")
+
+    def polymarket_bridge_supported_assets(self) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/bridge/supported-assets")
+
+    def polymarket_bridge_status(self, deposit_address: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/bridge/status/{deposit_address}")
+
+    # ── Polymarket — wallet management ─────────────────────────────
+
+    def polymarket_wallet_create(self, signature_type: str = "proxy") -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/wallet/create",
+            {"signatureType": signature_type},
+        )
+
+    def polymarket_wallet_import(self, private_key: str, signature_type: str = "proxy") -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/wallet/import",
+            {"privateKey": private_key, "signatureType": signature_type},
+        )
+
+    def polymarket_wallet_show(self) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/wallet/show")
+
+    def polymarket_wallet_address(self) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/wallet/address")
+
+    def polymarket_wallet_reset(self) -> dict:
+        return self._post(self.routing_url, "/api/polymarket/wallet/reset")
+
+    # ── Polymarket — market/event tags ─────────────────────────────
+
+    def polymarket_market_tags(self, market_id: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/markets/{market_id}/tags")
+
+    def polymarket_event_tags(self, event_id: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/events/{event_id}/tags")
+
+    # ── Polymarket — tags, series, comments, profiles, sports ──────
+
+    def polymarket_tag_get(self, id_or_slug: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/tags/{id_or_slug}")
+
+    def polymarket_tags_related(self, id_or_slug: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/tags/{id_or_slug}/related")
+
+    def polymarket_series_list(self, limit: int = 20, offset: int = 0) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/series", {"limit": limit, "offset": offset})
+
+    def polymarket_series_get(self, series_id: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/series/{series_id}")
+
+    def polymarket_comments_list(self, entity_type: str, entity_id: str) -> dict:
+        return self._get(
+            self.routing_url, "/api/polymarket/comments",
+            {"entityType": entity_type, "entityId": entity_id},
+        )
+
+    def polymarket_comment_get(self, comment_id: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/comments/{comment_id}")
+
+    def polymarket_comments_by_user(self, address: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/comments/user/{address}")
+
+    def polymarket_profile_get(self, address: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/profiles/{address}")
+
+    def polymarket_sports_list(self) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/sports")
+
+    def polymarket_sports_market_types(self) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/sports/market-types")
+
+    def polymarket_sports_teams(self, league: str, limit: int = 50) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/sports/teams", {"league": league, "limit": limit})
+
+    # ── Polymarket — CLOB batch & metadata ─────────────────────────
+
+    def polymarket_clob_books(self, token_ids: str) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/books", {"tokens": token_ids})
+
+    def polymarket_clob_batch_prices(self, token_ids: str, side: str = "buy") -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/batch-prices", {"tokens": token_ids, "side": side})
+
+    def polymarket_clob_midpoints(self, token_ids: str) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/midpoints", {"tokens": token_ids})
+
+    def polymarket_clob_spreads(self, token_ids: str) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/spreads", {"tokens": token_ids})
+
+    def polymarket_clob_last_trades(self, token_ids: str) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/last-trades", {"tokens": token_ids})
+
+    def polymarket_clob_tick_size(self, token_id: str) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/tick-size", {"token": token_id})
+
+    def polymarket_clob_fee_rate(self, token_id: str) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/fee-rate", {"token": token_id})
+
+    def polymarket_clob_neg_risk(self, token_id: str) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/neg-risk", {"token": token_id})
+
+    def polymarket_clob_ok(self) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/ok")
+
+    def polymarket_clob_time(self) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/time")
+
+    def polymarket_clob_geoblock(self) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/geoblock")
+
+    # ── Polymarket — CLOB trading extras ───────────────────────────
+
+    def polymarket_post_orders(
+        self, token_ids: str, side: str, prices: str, sizes: str,
+        order_type: str = "GTC", private_key: str | None = None,
+    ) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/clob/post-orders",
+            {
+                "tokens": token_ids, "side": side, "prices": prices,
+                "sizes": sizes, "orderType": order_type, "privateKey": private_key,
+            },
+        )
+
+    def polymarket_cancel_orders(self, order_ids: str, private_key: str | None = None) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/clob/cancel-orders",
+            {"orderIds": order_ids, "privateKey": private_key},
+        )
+
+    def polymarket_order_get(self, order_id: str, private_key: str | None = None) -> dict:
+        params: dict[str, Any] = {}
+        if private_key:
+            params["privateKey"] = private_key
+        return self._get(self.routing_url, f"/api/polymarket/clob/orders/{order_id}", params)
+
+    def polymarket_update_balance(self, asset_type: str = "collateral", token_id: str | None = None, private_key: str | None = None) -> dict:
+        body: dict[str, Any] = {"assetType": asset_type, "privateKey": private_key}
+        if token_id:
+            body["token"] = token_id
+        return self._post(self.routing_url, "/api/polymarket/clob/update-balance", body)
+
+    # ── Polymarket — rewards & API keys (authenticated) ────────────
+
+    def polymarket_rewards(self, date: str, private_key: str | None = None) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/rewards", {"date": date, "privateKey": private_key})
+
+    def polymarket_earnings(self, date: str, private_key: str | None = None) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/earnings", {"date": date, "privateKey": private_key})
+
+    def polymarket_earnings_markets(self, date: str, private_key: str | None = None) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/earnings-markets", {"date": date, "privateKey": private_key})
+
+    def polymarket_reward_percentages(self) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/reward-percentages")
+
+    def polymarket_current_rewards(self) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/current-rewards")
+
+    def polymarket_market_reward(self, condition_id: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/clob/market-reward/{condition_id}")
+
+    def polymarket_order_scoring(self, order_id: str, private_key: str | None = None) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/clob/order-scoring/{order_id}", {"privateKey": private_key} if private_key else None)
+
+    def polymarket_orders_scoring(self, order_ids: str, private_key: str | None = None) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/orders-scoring", {"orderIds": order_ids, "privateKey": private_key} if private_key else {"orderIds": order_ids})
+
+    def polymarket_api_keys(self, private_key: str | None = None) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/api-keys", {"privateKey": private_key} if private_key else None)
+
+    def polymarket_create_api_key(self, private_key: str | None = None) -> dict:
+        return self._post(self.routing_url, "/api/polymarket/clob/api-keys", {"privateKey": private_key})
+
+    def polymarket_delete_api_key(self, private_key: str | None = None) -> dict:
+        return self._delete(self.routing_url, "/api/polymarket/clob/api-keys", {"privateKey": private_key} if private_key else None)
+
+    def polymarket_account_status(self, private_key: str | None = None) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/account-status", {"privateKey": private_key} if private_key else None)
+
+    def polymarket_notifications(self, private_key: str | None = None) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/clob/notifications", {"privateKey": private_key} if private_key else None)
+
+    def polymarket_delete_notifications(self, notification_ids: str, private_key: str | None = None) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/clob/delete-notifications",
+            {"notificationIds": notification_ids, "privateKey": private_key},
+        )
+
+    # ── Polymarket — extended on-chain data ────────────────────────
+
+    def polymarket_data_closed_positions(self, address: str, limit: int = 25, offset: int = 0) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/data/closed-positions/{address}", {"limit": limit, "offset": offset})
+
+    def polymarket_data_traded(self, address: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/data/traded/{address}")
+
+    def polymarket_data_activity(self, address: str, limit: int = 25, offset: int = 0) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/data/activity/{address}", {"limit": limit, "offset": offset})
+
+    def polymarket_data_holders(self, condition_id: str, limit: int = 10) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/data/holders/{condition_id}", {"limit": limit})
+
+    def polymarket_data_open_interest(self, condition_id: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/data/open-interest/{condition_id}")
+
+    def polymarket_data_volume(self, event_id: str) -> dict:
+        return self._get(self.routing_url, f"/api/polymarket/data/volume/{event_id}")
+
+    def polymarket_data_builder_leaderboard(self, period: str = "month", limit: int = 25, offset: int = 0) -> dict:
+        return self._get(self.routing_url, "/api/polymarket/data/builder-leaderboard", {"period": period, "limit": limit, "offset": offset})
+
+    def polymarket_data_builder_volume(self, period: str = "month") -> dict:
+        return self._get(self.routing_url, "/api/polymarket/data/builder-volume", {"period": period})
+
+    # ── Polymarket — CTF extras ────────────────────────────────────
+
+    def polymarket_ctf_redeem_neg_risk(self, condition_id: str, amounts: str, private_key: str | None = None) -> dict:
+        return self._post(
+            self.routing_url, "/api/polymarket/ctf/redeem-neg-risk",
+            {"condition": condition_id, "amounts": amounts, "privateKey": private_key},
+        )
+
+    def polymarket_ctf_condition_id(self, oracle: str, question: str, outcomes: int) -> dict:
+        return self._get(
+            self.routing_url, "/api/polymarket/ctf/condition-id",
+            {"oracle": oracle, "question": question, "outcomes": outcomes},
+        )
+
+    def polymarket_ctf_collection_id(self, condition: str, index_set: int, parent_collection: str | None = None) -> dict:
+        params: dict[str, Any] = {"condition": condition, "indexSet": index_set}
+        if parent_collection:
+            params["parentCollection"] = parent_collection
+        return self._get(self.routing_url, "/api/polymarket/ctf/collection-id", params)
+
+    def polymarket_ctf_position_id(self, collateral: str, collection: str) -> dict:
+        return self._get(
+            self.routing_url, "/api/polymarket/ctf/position-id",
+            {"collateral": collateral, "collection": collection},
+        )
+
+    # ── Jupiter swap ────────────────────────────────────────────────
+
+    def jupiter_quote(
+        self,
+        input_mint: str,
+        output_mint: str,
+        amount: float,
+        slippage_bps: int = 100,
+    ) -> dict:
+        return self._post(
+            self.routing_url,
+            "/api/swap/jupiter/quote",
+            {
+                "inputMint": input_mint,
+                "outputMint": output_mint,
+                "amount": amount,
+                "slippageBps": slippage_bps,
+            },
+        )
+
+    def jupiter_swap_execute(
+        self,
+        input_mint: str,
+        output_mint: str,
+        amount: float,
+        slippage_bps: int = 100,
+        wallet_key: str | None = None,
+        priority_fee: int = 50000,
+    ) -> dict:
+        return self._post(
+            self.routing_url,
+            "/api/swap/jupiter/execute",
+            {
+                "inputMint": input_mint,
+                "outputMint": output_mint,
+                "amount": amount,
+                "slippageBps": slippage_bps,
+                "walletKey": wallet_key,
+                "priorityFee": priority_fee,
+            },
+        )
+
+    # ── Uniswap swap ───────────────────────────────────────────────
+
+    def uniswap_quote(
+        self,
+        input_address: str,
+        output_address: str,
+        amount: float,
+        chain: str = "ethereum",
+        slippage_bps: int = 50,
+    ) -> dict:
+        return self._post(
+            self.routing_url,
+            "/api/swap/uniswap/quote",
+            {
+                "inputAddress": input_address,
+                "outputAddress": output_address,
+                "amount": amount,
+                "chain": chain,
+                "slippageBps": slippage_bps,
+            },
+        )
+
+    def uniswap_swap_execute(
+        self,
+        input_address: str,
+        output_address: str,
+        amount: float,
+        chain: str = "ethereum",
+        slippage_bps: int = 50,
+        wallet_key: str | None = None,
+        gas_limit: int | None = None,
+    ) -> dict:
+        body: dict[str, Any] = {
+            "inputAddress": input_address,
+            "outputAddress": output_address,
+            "amount": amount,
+            "chain": chain,
+            "slippageBps": slippage_bps,
+            "walletKey": wallet_key,
+        }
+        if gas_limit:
+            body["gasLimit"] = gas_limit
+        return self._post(self.routing_url, "/api/swap/uniswap/execute", body)
+
+    # ── SushiSwap ──────────────────────────────────────────────────
+
+    def sushi_swap(
+        self,
+        input_address: str,
+        output_address: str,
+        amount: float,
+        chain: str = "ethereum",
+        slippage_bps: int = 50,
+        wallet_key: str | None = None,
+        quote_only: bool = False,
+    ) -> dict:
+        return self._post(
+            self.routing_url,
+            "/api/swap/sushi/execute",
+            {
+                "inputAddress": input_address,
+                "outputAddress": output_address,
+                "amount": amount,
+                "chain": chain,
+                "slippageBps": slippage_bps,
+                "walletKey": wallet_key,
+                "quoteOnly": quote_only,
+            },
+        )
+
+    # ── GMX V2 ─────────────────────────────────────────────────────
+
+    def gmx_markets(self) -> dict:
+        return self._get(self.routing_url, "/api/dex/gmx/markets", None)
+
+    def gmx_order(
+        self,
+        symbol: str,
+        side: str,
+        size_usd: float,
+        leverage: float = 1.0,
+        order_type: str = "market",
+        price: float | None = None,
+        stop_loss: float | None = None,
+        take_profit: float | None = None,
+        wallet_key: str | None = None,
+    ) -> dict:
+        body: dict[str, Any] = {
+            "symbol": symbol,
+            "side": side,
+            "sizeUsd": size_usd,
+            "leverage": leverage,
+            "orderType": order_type,
+            "walletKey": wallet_key,
+        }
+        if price is not None:
+            body["price"] = price
+        if stop_loss is not None:
+            body["stopLoss"] = stop_loss
+        if take_profit is not None:
+            body["takeProfit"] = take_profit
+        return self._post(self.routing_url, "/api/dex/gmx/order", body)
+
+    def gmx_positions(self, wallet_key: str) -> dict:
+        return self._post(self.routing_url, "/api/dex/gmx/positions", {"walletKey": wallet_key})
+
+    def gmx_close_position(self, position_key: str, wallet_key: str) -> dict:
+        return self._post(
+            self.routing_url,
+            "/api/dex/gmx/close",
+            {"positionKey": position_key, "walletKey": wallet_key},
+        )
+
+    # ── dYdX V4 ────────────────────────────────────────────────────
+
+    def dydx_markets(self) -> dict:
+        return self._get(self.routing_url, "/api/dex/dydx/markets", None)
+
+    def dydx_order(
+        self,
+        symbol: str,
+        side: str,
+        size: float,
+        order_type: str = "market",
+        price: float | None = None,
+        leverage: float = 1.0,
+        reduce_only: bool = False,
+        time_in_force: str = "GTT",
+        mnemonic: str | None = None,
+    ) -> dict:
+        body: dict[str, Any] = {
+            "symbol": symbol,
+            "side": side,
+            "size": size,
+            "orderType": order_type,
+            "leverage": leverage,
+            "reduceOnly": reduce_only,
+            "timeInForce": time_in_force,
+            "mnemonic": mnemonic,
+        }
+        if price is not None:
+            body["price"] = price
+        return self._post(self.routing_url, "/api/dex/dydx/order", body)
+
+    def dydx_positions(self, mnemonic: str) -> dict:
+        return self._post(self.routing_url, "/api/dex/dydx/positions", {"mnemonic": mnemonic})
+
+    def dydx_orderbook(self, symbol: str) -> dict:
+        return self._get(self.routing_url, "/api/dex/dydx/orderbook", {"symbol": symbol})
+
+    # ── Aevo ───────────────────────────────────────────────────────
+
+    def aevo_markets(self, market_type: str = "all") -> dict:
+        return self._get(self.routing_url, "/api/dex/aevo/markets", {"type": market_type})
+
+    def aevo_order(
+        self,
+        instrument: str,
+        side: str,
+        amount: float,
+        order_type: str = "market",
+        price: float | None = None,
+        leverage: float = 1.0,
+        reduce_only: bool = False,
+        wallet_key: str | None = None,
+        api_key: str | None = None,
+        api_secret: str | None = None,
+    ) -> dict:
+        body: dict[str, Any] = {
+            "instrument": instrument,
+            "side": side,
+            "amount": amount,
+            "orderType": order_type,
+            "leverage": leverage,
+            "reduceOnly": reduce_only,
+            "walletKey": wallet_key,
+            "apiKey": api_key,
+            "apiSecret": api_secret,
+        }
+        if price is not None:
+            body["price"] = price
+        return self._post(self.routing_url, "/api/dex/aevo/order", body)
+
+    def aevo_positions(self, api_key: str, api_secret: str | None = None) -> dict:
+        return self._post(
+            self.routing_url,
+            "/api/dex/aevo/positions",
+            {"apiKey": api_key, "apiSecret": api_secret},
+        )
+
+    def aevo_orderbook(self, instrument: str) -> dict:
+        return self._get(self.routing_url, "/api/dex/aevo/orderbook", {"instrument": instrument})
+
+    # ── wallet creation ────────────────────────────────────────────
+
+    def create_wallet(self, wallet_type: str, options: dict | None = None) -> dict:
+        body: dict[str, Any] = {"walletType": wallet_type}
+        if options:
+            body.update(options)
+        return self._post(self.routing_url, "/api/wallet/create", body)
+
+    def link_wallet(self, wallet_address: str, wallet_type: str, is_primary: bool = False) -> dict:
+        return self._post(
+            self.routing_url,
+            "/api/wallet/link",
+            {"walletAddress": wallet_address, "walletType": wallet_type, "isPrimary": is_primary},
+        )
+
+    def list_wallets(self) -> dict:
+        return self._get(self.routing_url, "/api/wallet/list", None)
+
+    def wallet_balance_onchain(self, wallet_address: str, chain: str) -> dict:
+        return self._get(
+            self.routing_url,
+            "/api/wallet/balance",
+            {"address": wallet_address, "chain": chain},
+        )