trading-cli 0.3.0__py3-none-any.whl

fastbooks_cli/commands/dex.py

@@ -0,0 +1,507 @@
+"""DEX venues command group — GMX, dYdX, Aevo perpetual trading."""
+
+from __future__ import annotations
+
+import click
+
+from ..client import FastBooksClient
+from ..output import emit, emit_error, format_table, require_experimental
+
+# ── venue configs ────────────────────────────────────────────────────────
+
+DEX_PERP_VENUES = {
+    "gmx": {
+        "name": "GMX",
+        "chain": "arbitrum",
+        "markets": "perpetual",
+        "auth": "EVM private key",
+        "api_base": "https://api.gmx.io",
+        "notes": "GMX V2 on Arbitrum. Decentralized perps with GLP liquidity.",
+    },
+    "dydx": {
+        "name": "dYdX",
+        "chain": "dydx-chain (Cosmos)",
+        "markets": "perpetual",
+        "auth": "dYdX mnemonic or API key",
+        "api_base": "https://indexer.dydx.trade/v4",
+        "notes": "dYdX V4 sovereign chain. Fully decentralized orderbook.",
+    },
+    "aevo": {
+        "name": "Aevo",
+        "chain": "aevo-rollup (Ethereum L2)",
+        "markets": "perpetual, options",
+        "auth": "EVM private key + API key",
+        "api_base": "https://api.aevo.xyz",
+        "notes": "High-performance options and perps on custom L2 rollup.",
+    },
+}
+
+
+@click.group()
+@click.pass_context
+def dex(ctx):
+    """[experimental] DEX perpetual venues: GMX, dYdX, Aevo.
+
+    NOTE: requires a DEX-perps router not enabled on standard FastBooks
+    deployments. Gated behind FASTBOOKS_EXPERIMENTAL=1.
+
+    Trade perpetual futures on decentralized exchanges. Each venue has
+    different chain requirements and authentication methods.
+
+    GMX:  Arbitrum-based perps. EVM wallet signing.
+    dYdX: Sovereign Cosmos chain. Mnemonic or API key.
+    Aevo: Custom L2 rollup. EVM wallet + API key.
+    """
+    require_experimental(ctx, "dex")
+
+
+# ── venue info ───────────────────────────────────────────────────────────
+
+@dex.command("venues")
+@click.pass_context
+def dex_venues(ctx):
+    """List all DEX perpetual venues and their requirements.
+
+    Example: fastbooks dex venues
+    """
+    data = {"venues": list(DEX_PERP_VENUES.values())}
+    emit(ctx, data, lambda d: _format_dex_venues(d))
+
+
+def _format_dex_venues(data: dict) -> str:
+    lines = ["", "  DEX Perpetual Venues", "  ====================", ""]
+    for v in data["venues"]:
+        lines.append(f"  {v['name']} ({v['chain']})")
+        lines.append(f"    Markets: {v['markets']}")
+        lines.append(f"    Auth:    {v['auth']}")
+        lines.append(f"    Notes:   {v['notes']}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# GMX V2 (Arbitrum)
+# ══════════════════════════════════════════════════════════════════════════
+
+@dex.group()
+def gmx():
+    """GMX V2 perpetual trading on Arbitrum.
+
+    Trade perpetual futures using GMX's decentralized liquidity pools.
+    Requires an Arbitrum EVM private key.
+
+    Supported pairs: ETH/USD, BTC/USD, ARB/USD, SOL/USD, LINK/USD, etc.
+    Leverage: up to 50x.
+    """
+    pass
+
+
+@gmx.command("markets")
+@click.pass_context
+def gmx_markets(ctx):
+    """List available GMX markets.
+
+    Example: fastbooks dex gmx markets
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.gmx_markets()
+        emit(ctx, data, lambda d: _format_perp_markets(d, "GMX"))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@gmx.command("order")
+@click.argument("symbol")
+@click.argument("side", type=click.Choice(["long", "short"], case_sensitive=False))
+@click.argument("size_usd", type=float)
+@click.option("--leverage", "-l", type=float, default=1.0, help="Leverage multiplier.")
+@click.option("--order-type", type=click.Choice(["market", "limit"]), default="market")
+@click.option("--price", "-p", type=float, default=None, help="Limit price.")
+@click.option("--stop-loss", type=float, default=None, help="Stop loss price.")
+@click.option("--take-profit", type=float, default=None, help="Take profit price.")
+@click.option("--wallet-key", envvar="EVM_PRIVATE_KEY", default=None)
+@click.option("--confirm/--no-confirm", default=True)
+@click.pass_context
+def gmx_order(ctx, symbol, side, size_usd, leverage, order_type, price, stop_loss, take_profit, wallet_key, confirm):
+    """Open a perpetual position on GMX.
+
+    SYMBOL: Market pair (e.g. ETH/USD, BTC/USD).
+    SIDE: long or short.
+    SIZE_USD: Position size in USD.
+
+    Examples:
+        fastbooks dex gmx order ETH/USD long 1000 --leverage 5
+        fastbooks dex gmx order BTC/USD short 5000 -l 10 --stop-loss 70000
+        fastbooks dex gmx order ARB/USD long 500 --order-type limit --price 1.50
+    """
+    client: FastBooksClient = ctx.obj
+
+    if not wallet_key:
+        emit_error(ctx, "EVM private key required. Use --wallet-key or set EVM_PRIVATE_KEY.")
+        ctx.exit(1)
+        return
+
+    if confirm and not ctx.find_root().params.get("json_output", False):
+        click.echo(f"\n  GMX {side.upper()} {symbol}: ${size_usd} @ {leverage}x ({order_type})")
+        if price:
+            click.echo(f"  Limit price: {price}")
+        if stop_loss:
+            click.echo(f"  Stop loss: {stop_loss}")
+        if take_profit:
+            click.echo(f"  Take profit: {take_profit}")
+        if not click.confirm("\n  Execute?"):
+            click.echo("  Cancelled.")
+            return
+
+    try:
+        data = client.gmx_order(
+            symbol=symbol, side=side, size_usd=size_usd,
+            leverage=leverage, order_type=order_type, price=price,
+            stop_loss=stop_loss, take_profit=take_profit,
+            wallet_key=wallet_key,
+        )
+        emit(ctx, data, lambda d: _format_perp_order(d, "GMX"))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@gmx.command("positions")
+@click.option("--wallet-key", envvar="EVM_PRIVATE_KEY", default=None)
+@click.pass_context
+def gmx_positions(ctx, wallet_key):
+    """List open GMX positions.
+
+    Example: fastbooks dex gmx positions
+    """
+    client: FastBooksClient = ctx.obj
+    if not wallet_key:
+        emit_error(ctx, "EVM private key required.")
+        ctx.exit(1)
+        return
+    try:
+        data = client.gmx_positions(wallet_key)
+        emit(ctx, data, lambda d: _format_perp_positions(d, "GMX"))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@gmx.command("close")
+@click.argument("position_key")
+@click.option("--wallet-key", envvar="EVM_PRIVATE_KEY", default=None)
+@click.option("--confirm/--no-confirm", default=True)
+@click.pass_context
+def gmx_close(ctx, position_key, wallet_key, confirm):
+    """Close an open GMX position.
+
+    Example: fastbooks dex gmx close 0xabc123...
+    """
+    client: FastBooksClient = ctx.obj
+    if not wallet_key:
+        emit_error(ctx, "EVM private key required.")
+        ctx.exit(1)
+        return
+    if confirm and not ctx.find_root().params.get("json_output", False):
+        if not click.confirm(f"  Close position {position_key[:16]}...?"):
+            click.echo("  Cancelled.")
+            return
+    try:
+        data = client.gmx_close_position(position_key, wallet_key)
+        emit(ctx, data, lambda d: f"  Position closed. Tx: {d.get('txHash', '?')}")
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# dYdX V4
+# ══════════════════════════════════════════════════════════════════════════
+
+@dex.group()
+def dydx():
+    """dYdX V4 perpetual trading on dYdX Chain.
+
+    Trade perpetual futures on dYdX's sovereign Cosmos-based chain.
+    Requires a dYdX mnemonic or API credentials.
+
+    Supported pairs: ETH-USD, BTC-USD, SOL-USD, AVAX-USD, etc.
+    Leverage: up to 20x.
+    """
+    pass
+
+
+@dydx.command("markets")
+@click.pass_context
+def dydx_markets(ctx):
+    """List available dYdX markets.
+
+    Example: fastbooks dex dydx markets
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.dydx_markets()
+        emit(ctx, data, lambda d: _format_perp_markets(d, "dYdX"))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@dydx.command("order")
+@click.argument("symbol")
+@click.argument("side", type=click.Choice(["long", "short"], case_sensitive=False))
+@click.argument("size", type=float)
+@click.option("--order-type", type=click.Choice(["market", "limit"]), default="market")
+@click.option("--price", "-p", type=float, default=None, help="Limit price.")
+@click.option("--leverage", "-l", type=float, default=1.0)
+@click.option("--reduce-only", is_flag=True, help="Reduce-only order.")
+@click.option("--time-in-force", type=click.Choice(["GTT", "FOK", "IOC"]), default="GTT")
+@click.option("--mnemonic", envvar="DYDX_MNEMONIC", default=None, help="dYdX mnemonic (or set DYDX_MNEMONIC).")
+@click.option("--confirm/--no-confirm", default=True)
+@click.pass_context
+def dydx_order(ctx, symbol, side, size, order_type, price, leverage, reduce_only, time_in_force, mnemonic, confirm):
+    """Place a perpetual order on dYdX.
+
+    SYMBOL: Market pair (e.g. ETH-USD, BTC-USD).
+    SIDE: long or short.
+    SIZE: Position size in base asset.
+
+    Examples:
+        fastbooks dex dydx order ETH-USD long 1.0 --leverage 5
+        fastbooks dex dydx order BTC-USD short 0.1 -l 10 --order-type limit --price 65000
+        fastbooks dex dydx order SOL-USD long 50 --reduce-only
+    """
+    client: FastBooksClient = ctx.obj
+
+    if not mnemonic:
+        emit_error(ctx, "dYdX mnemonic required. Use --mnemonic or set DYDX_MNEMONIC.")
+        ctx.exit(1)
+        return
+
+    if confirm and not ctx.find_root().params.get("json_output", False):
+        click.echo(f"\n  dYdX {side.upper()} {size} {symbol} @ {leverage}x ({order_type})")
+        if price:
+            click.echo(f"  Limit price: {price}")
+        if not click.confirm("\n  Execute?"):
+            click.echo("  Cancelled.")
+            return
+
+    try:
+        data = client.dydx_order(
+            symbol=symbol, side=side, size=size,
+            order_type=order_type, price=price, leverage=leverage,
+            reduce_only=reduce_only, time_in_force=time_in_force,
+            mnemonic=mnemonic,
+        )
+        emit(ctx, data, lambda d: _format_perp_order(d, "dYdX"))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@dydx.command("positions")
+@click.option("--mnemonic", envvar="DYDX_MNEMONIC", default=None)
+@click.pass_context
+def dydx_positions(ctx, mnemonic):
+    """List open dYdX positions.
+
+    Example: fastbooks dex dydx positions
+    """
+    client: FastBooksClient = ctx.obj
+    if not mnemonic:
+        emit_error(ctx, "dYdX mnemonic required.")
+        ctx.exit(1)
+        return
+    try:
+        data = client.dydx_positions(mnemonic)
+        emit(ctx, data, lambda d: _format_perp_positions(d, "dYdX"))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@dydx.command("orderbook")
+@click.argument("symbol")
+@click.pass_context
+def dydx_orderbook(ctx, symbol):
+    """Get dYdX orderbook for a market.
+
+    Example: fastbooks dex dydx orderbook ETH-USD
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.dydx_orderbook(symbol)
+        emit(ctx, data)
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+# ══════════════════════════════════════════════════════════════════════════
+# Aevo
+# ══════════════════════════════════════════════════════════════════════════
+
+@dex.group()
+def aevo():
+    """Aevo perpetual and options trading on Aevo L2.
+
+    Trade perpetual futures and options on Aevo's high-performance rollup.
+    Requires EVM private key and Aevo API credentials.
+
+    Supported pairs: ETH-PERP, BTC-PERP, SOL-PERP, ARB-PERP, etc.
+    Also supports options: ETH-C-*, BTC-P-*, etc.
+    Leverage: up to 20x.
+    """
+    pass
+
+
+@aevo.command("markets")
+@click.option("--type", "market_type", type=click.Choice(["perpetual", "options", "all"]), default="all")
+@click.pass_context
+def aevo_markets(ctx, market_type):
+    """List available Aevo markets.
+
+    Examples:
+        fastbooks dex aevo markets
+        fastbooks dex aevo markets --type perpetual
+        fastbooks dex aevo markets --type options
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.aevo_markets(market_type)
+        emit(ctx, data, lambda d: _format_perp_markets(d, "Aevo"))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@aevo.command("order")
+@click.argument("instrument")
+@click.argument("side", type=click.Choice(["buy", "sell"], case_sensitive=False))
+@click.argument("amount", type=float)
+@click.option("--order-type", type=click.Choice(["market", "limit"]), default="market")
+@click.option("--price", "-p", type=float, default=None)
+@click.option("--leverage", "-l", type=float, default=1.0)
+@click.option("--reduce-only", is_flag=True)
+@click.option("--wallet-key", envvar="EVM_PRIVATE_KEY", default=None)
+@click.option("--api-key", envvar="AEVO_API_KEY", default=None)
+@click.option("--api-secret", envvar="AEVO_API_SECRET", default=None)
+@click.option("--confirm/--no-confirm", default=True)
+@click.pass_context
+def aevo_order(ctx, instrument, side, amount, order_type, price, leverage, reduce_only, wallet_key, api_key, api_secret, confirm):
+    """Place an order on Aevo (perps or options).
+
+    INSTRUMENT: e.g. ETH-PERP, BTC-PERP, ETH-20250328-4000-C.
+    SIDE: buy or sell.
+    AMOUNT: Position size.
+
+    Examples:
+        fastbooks dex aevo order ETH-PERP buy 1.0 --leverage 5
+        fastbooks dex aevo order BTC-PERP sell 0.1 --order-type limit --price 65000
+        fastbooks dex aevo order ETH-20250328-4000-C buy 5 --price 150
+    """
+    client: FastBooksClient = ctx.obj
+
+    if not wallet_key:
+        emit_error(ctx, "EVM private key required. Use --wallet-key or set EVM_PRIVATE_KEY.")
+        ctx.exit(1)
+        return
+
+    if confirm and not ctx.find_root().params.get("json_output", False):
+        click.echo(f"\n  Aevo {side.upper()} {amount} {instrument} @ {leverage}x ({order_type})")
+        if price:
+            click.echo(f"  Price: {price}")
+        if not click.confirm("\n  Execute?"):
+            click.echo("  Cancelled.")
+            return
+
+    try:
+        data = client.aevo_order(
+            instrument=instrument, side=side, amount=amount,
+            order_type=order_type, price=price, leverage=leverage,
+            reduce_only=reduce_only, wallet_key=wallet_key,
+            api_key=api_key, api_secret=api_secret,
+        )
+        emit(ctx, data, lambda d: _format_perp_order(d, "Aevo"))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@aevo.command("positions")
+@click.option("--api-key", envvar="AEVO_API_KEY", default=None)
+@click.option("--api-secret", envvar="AEVO_API_SECRET", default=None)
+@click.pass_context
+def aevo_positions(ctx, api_key, api_secret):
+    """List open Aevo positions.
+
+    Example: fastbooks dex aevo positions
+    """
+    client: FastBooksClient = ctx.obj
+    if not api_key:
+        emit_error(ctx, "Aevo API key required. Use --api-key or set AEVO_API_KEY.")
+        ctx.exit(1)
+        return
+    try:
+        data = client.aevo_positions(api_key, api_secret)
+        emit(ctx, data, lambda d: _format_perp_positions(d, "Aevo"))
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@aevo.command("orderbook")
+@click.argument("instrument")
+@click.pass_context
+def aevo_orderbook(ctx, instrument):
+    """Get Aevo orderbook for an instrument.
+
+    Example: fastbooks dex aevo orderbook ETH-PERP
+    """
+    client: FastBooksClient = ctx.obj
+    try:
+        data = client.aevo_orderbook(instrument)
+        emit(ctx, data)
+    except Exception as e:
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+# ── shared formatters ────────────────────────────────────────────────────
+
+def _format_perp_markets(data, venue_name: str) -> str:
+    items = data if isinstance(data, list) else data.get("markets", data.get("data", []))
+    if not isinstance(items, list):
+        return str(data)
+    if not items:
+        return f"  No {venue_name} markets found."
+    return f"  {venue_name} Markets\n  {'=' * 20}\n" + format_table(
+        items[:30],
+        ["symbol", "indexPrice", "markPrice", "fundingRate", "openInterest", "maxLeverage"],
+        ["Symbol", "Index", "Mark", "Funding", "OI", "Max Lev"],
+    )
+
+
+def _format_perp_order(data: dict, venue_name: str) -> str:
+    lines = [f"\n  {venue_name} Order"]
+    if data.get("orderId") or data.get("id"):
+        lines.append(f"  ID: {data.get('orderId', data.get('id', '?'))}")
+    if data.get("txHash"):
+        lines.append(f"  Tx: {data['txHash']}")
+    lines.append(f"  Status: {data.get('status', '?')}")
+    return "\n".join(lines)
+
+
+def _format_perp_positions(data, venue_name: str) -> str:
+    items = data if isinstance(data, list) else data.get("positions", data.get("data", []))
+    if not isinstance(items, list):
+        return str(data)
+    if not items:
+        return f"  No open {venue_name} positions."
+    return f"  {venue_name} Positions\n" + format_table(
+        items,
+        ["symbol", "side", "size", "entryPrice", "markPrice", "unrealizedPnl", "leverage"],
+        ["Symbol", "Side", "Size", "Entry", "Mark", "PnL", "Leverage"],
+    )

fastbooks_cli/commands/direct.py

@@ -0,0 +1,150 @@
+"""`direct` — standalone exchange access via ccxt (NO FastBooks backend required).
+
+Public data is keyless. Trading reads keys from the environment:
+CCXT_<EXCHANGE>_API_KEY / _SECRET / _PASSWORD  (e.g. CCXT_BINANCE_API_KEY).
+This is the group that makes the CLI a self-contained, backend-free trader for 100+ exchanges.
+"""
+
+from __future__ import annotations
+
+import click
+
+from .. import direct as d
+from ..output import emit, emit_error
+
+
+@click.group()
+def direct():
+    """Trade & read 100+ exchanges DIRECTLY via ccxt — no backend, keyless for data.
+
+    Public data (ticker/ohlcv/orderbook/markets) needs no key. Trading reads creds from
+    env: CCXT_<EXCHANGE>_API_KEY / _SECRET / _PASSWORD. Add --sandbox for testnet where supported.
+    """
+
+
+@direct.command("exchanges")
+@click.option("--search", default=None, help="Filter by substring.")
+@click.pass_context
+def exchanges_cmd(ctx: click.Context, search: str | None):
+    """List all exchanges ccxt supports (100+)."""
+    try:
+        xs = d.list_exchanges()
+        if search:
+            xs = [x for x in xs if search.lower() in x.lower()]
+        emit(ctx, {"count": len(xs), "exchanges": xs},
+             lambda r: f"{r['count']} exchanges:\n" + ", ".join(r["exchanges"]))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@direct.command("ticker")
+@click.argument("exchange")
+@click.argument("symbol")
+@click.pass_context
+def ticker_cmd(ctx: click.Context, exchange: str, symbol: str):
+    """Live ticker (keyless). e.g. direct ticker binance BTC/USDT"""
+    try:
+        emit(ctx, d.ticker(exchange, symbol))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@direct.command("ohlcv")
+@click.argument("exchange")
+@click.argument("symbol")
+@click.option("--timeframe", "-t", default="1h", help="1m,5m,15m,1h,4h,1d,...")
+@click.option("--limit", "-n", default=100, type=int)
+@click.pass_context
+def ohlcv_cmd(ctx: click.Context, exchange: str, symbol: str, timeframe: str, limit: int):
+    """OHLCV candles (keyless). e.g. direct ohlcv kraken ETH/USD -t 15m -n 200"""
+    try:
+        emit(ctx, d.ohlcv(exchange, symbol, timeframe, limit))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@direct.command("orderbook")
+@click.argument("exchange")
+@click.argument("symbol")
+@click.option("--depth", "-d", default=10, type=int)
+@click.pass_context
+def orderbook_cmd(ctx: click.Context, exchange: str, symbol: str, depth: int):
+    """Order book (keyless). e.g. direct orderbook okx BTC/USDT -d 20"""
+    try:
+        emit(ctx, d.orderbook(exchange, symbol, depth))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@direct.command("markets")
+@click.argument("exchange")
+@click.option("--quote", default=None, help="Filter by quote asset, e.g. USDT.")
+@click.option("--limit", "-n", default=200, type=int)
+@click.pass_context
+def markets_cmd(ctx: click.Context, exchange: str, quote: str | None, limit: int):
+    """List tradable symbols on an exchange (keyless)."""
+    try:
+        emit(ctx, d.markets(exchange, quote, limit))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@direct.command("balance")
+@click.argument("exchange")
+@click.pass_context
+def balance_cmd(ctx: click.Context, exchange: str):
+    """Account balance (needs CCXT_<EXCHANGE>_API_KEY/_SECRET env)."""
+    try:
+        emit(ctx, d.balance(exchange))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@direct.command("positions")
+@click.argument("exchange")
+@click.pass_context
+def positions_cmd(ctx: click.Context, exchange: str):
+    """Open positions (needs creds; derivatives exchanges only)."""
+    try:
+        emit(ctx, d.positions(exchange))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)
+
+
+@direct.command("order")
+@click.argument("exchange")
+@click.argument("symbol")
+@click.argument("side", type=click.Choice(["buy", "sell"]))
+@click.argument("amount", type=float)
+@click.option("--type", "order_type", type=click.Choice(["market", "limit"]), default="market")
+@click.option("--price", type=float, default=None, help="Required for limit orders.")
+@click.option("--sandbox", is_flag=True, help="Use the exchange testnet where supported.")
+@click.option("--yes", is_flag=True, help="Skip the live-order confirmation.")
+@click.pass_context
+def order_cmd(ctx, exchange, symbol, side, amount, order_type, price, sandbox, yes):
+    """Place an order directly on an exchange (needs creds).
+
+    e.g. direct order binance BTC/USDT buy 0.001 --type limit --price 60000
+    """
+    if order_type == "limit" and price is None:
+        emit_error(ctx, "Limit orders require --price.")
+        ctx.exit(1)
+    if not sandbox and not yes:
+        root = ctx.find_root()
+        if not root.params.get("json_output"):
+            click.confirm(
+                f"LIVE order: {side} {amount} {symbol} on {exchange} ({order_type}). Proceed?",
+                abort=True,
+            )
+    try:
+        emit(ctx, d.place_order(exchange, symbol, side, order_type, amount, price, sandbox=sandbox))
+    except Exception as e:  # noqa: BLE001
+        emit_error(ctx, str(e))
+        ctx.exit(1)