o2-cli 0.1.0__py3-none-any.whl

o2_cli/commands/admin.py

@@ -0,0 +1,147 @@
+"""o2 admin commands - Admin operations."""
+
+import asyncio
+
+import typer
+
+from o2_cli.cli import get_state
+from o2_cli.client import O2Client
+from o2_cli.config import load_config, get_active_profile
+from o2_cli.exceptions import APIError, ConnectionError
+from o2_cli.output import OutputFormatter
+
+app = typer.Typer(help="Admin operations")
+
+
+@app.command("gas-status")
+def gas_status():
+    """Show gas pool status and funding info."""
+    asyncio.run(_gas_status())
+
+
+async def _gas_status():
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    if not profile.token and profile.auth_type == "jwt":
+        formatter.print_error("Not authenticated. Run 'o2 auth test-login' first.")
+        raise typer.Exit(1)
+
+    async with O2Client(api_url, timeout) as client:
+        client.set_jwt(profile.token)
+        if profile.api_key_id:
+            client.set_api_key(profile.api_key_id, profile.api_secret)
+        try:
+            data = await client.get("/admin/gas/status")
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("proxy-list")
+def proxy_list():
+    """List all deposit proxy addresses."""
+    asyncio.run(_proxy_list())
+
+
+async def _proxy_list():
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    if not profile.token and profile.auth_type == "jwt":
+        formatter.print_error("Not authenticated. Run 'o2 auth test-login' first.")
+        raise typer.Exit(1)
+
+    async with O2Client(api_url, timeout) as client:
+        client.set_jwt(profile.token)
+        if profile.api_key_id:
+            client.set_api_key(profile.api_key_id, profile.api_secret)
+        try:
+            data = await client.get("/admin/proxy-addresses")
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("api-keys")
+def api_keys():
+    """List registered API keys."""
+    asyncio.run(_api_keys())
+
+
+async def _api_keys():
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    if not profile.token and profile.auth_type == "jwt":
+        formatter.print_error("Not authenticated. Run 'o2 auth test-login' first.")
+        raise typer.Exit(1)
+
+    async with O2Client(api_url, timeout) as client:
+        client.set_jwt(profile.token)
+        if profile.api_key_id:
+            client.set_api_key(profile.api_key_id, profile.api_secret)
+        try:
+            data = await client.get("/admin/api-keys")
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("reconcile")
+def reconcile():
+    """Trigger order reconciliation."""
+    asyncio.run(_reconcile())
+
+
+async def _reconcile():
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    if not profile.token and profile.auth_type == "jwt":
+        formatter.print_error("Not authenticated. Run 'o2 auth test-login' first.")
+        raise typer.Exit(1)
+
+    async with O2Client(api_url, timeout) as client:
+        client.set_jwt(profile.token)
+        if profile.api_key_id:
+            client.set_api_key(profile.api_key_id, profile.api_secret)
+        try:
+            data = await client.post("/admin/reconcile")
+            formatter.print_raw(data)
+            if not state["json_output"]:
+                formatter.print_success("Reconciliation triggered")
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)

o2_cli/commands/auth.py

@@ -0,0 +1,140 @@
+"""o2 auth commands - Authentication management."""
+
+import asyncio
+
+import typer
+
+from o2_cli.client import O2Client
+from o2_cli.config import save_token
+from o2_cli.exceptions import APIError, ConnectionError
+from o2_cli.commands._helpers import resolve_context, setup_client
+
+app = typer.Typer(help="Authentication commands")
+
+
+@app.command("test-login")
+def test_login():
+    """Dev: get a test JWT token."""
+    asyncio.run(_test_login())
+
+
+async def _test_login():
+    profile, formatter, api_url, timeout = resolve_context()
+
+    async with O2Client(api_url, timeout) as client:
+        try:
+            data = await client.auth_test_login()
+            token = data.get("token") or data.get("access_token")
+            if token:
+                save_token(profile.auth_type if profile.auth_type == "jwt" else "default", token)
+                # Save to active profile
+                from o2_cli.config import load_config, get_active_profile, CONFIG_FILE
+                config = load_config(CONFIG_FILE)
+                save_token(config.active_profile, token)
+                formatter.print_success("Logged in (token saved to config)")
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("challenge")
+def challenge(
+    wallet: str = typer.Option(..., "--wallet", "-w", help="Wallet address"),
+):
+    """Get a login challenge nonce for wallet signing."""
+    asyncio.run(_challenge(wallet))
+
+
+async def _challenge(wallet: str):
+    profile, formatter, api_url, timeout = resolve_context()
+
+    async with O2Client(api_url, timeout) as client:
+        try:
+            data = await client.auth_challenge(wallet)
+            formatter.print_raw(data)
+            formatter.print_success("Sign this message with your wallet to login")
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("login")
+def login(
+    wallet: str = typer.Option(..., "--wallet", "-w", help="Wallet address"),
+    signature: str = typer.Option(..., "--signature", "-s", help="Wallet signature"),
+    message: str = typer.Option(..., "--message", "-m", help="Signed message"),
+):
+    """Login with wallet signature."""
+    asyncio.run(_login(wallet, signature, message))
+
+
+async def _login(wallet: str, signature: str, message: str):
+    profile, formatter, api_url, timeout = resolve_context()
+
+    async with O2Client(api_url, timeout) as client:
+        try:
+            data = await client.auth_signature_login(wallet, signature, message)
+            token = data.get("token") or data.get("access_token")
+            if token:
+                from o2_cli.config import load_config, CONFIG_FILE
+                config = load_config(CONFIG_FILE)
+                save_token(config.active_profile, token)
+                formatter.print_success(f"Logged in as {wallet[:8]}...")
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("me")
+def me():
+    """Show current user info."""
+    asyncio.run(_me())
+
+
+async def _me():
+    profile, formatter, api_url, timeout = resolve_context()
+
+    async with O2Client(api_url, timeout) as client:
+        setup_client(client, profile)
+        try:
+            data = await client.auth_me()
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("session")
+def session():
+    """Check session status."""
+    asyncio.run(_session())
+
+
+async def _session():
+    profile, formatter, api_url, timeout = resolve_context()
+
+    async with O2Client(api_url, timeout) as client:
+        setup_client(client, profile)
+        try:
+            data = await client.auth_session_status()
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)

o2_cli/commands/balance.py

@@ -0,0 +1,64 @@
+"""o2 balance commands - Balance queries."""
+
+import asyncio
+
+import typer
+
+from o2_cli.client import O2Client
+from o2_cli.exceptions import APIError, ConnectionError
+from o2_cli.commands._helpers import resolve_context, setup_client, require_auth
+
+app = typer.Typer(help="Balance queries")
+
+
+@app.command("show")
+def show():
+    """Show account balance (cash + bonus)."""
+    asyncio.run(_show())
+
+
+async def _show():
+    profile, formatter, api_url, timeout = resolve_context()
+
+    if not require_auth(profile, formatter):
+        raise typer.Exit(1)
+
+    async with O2Client(api_url, timeout) as client:
+        setup_client(client, profile)
+        try:
+            data = await client.get_balance()
+            formatter.print_balance(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("history")
+def history(
+    limit: int = typer.Option(50, "--limit", "-n", help="Number of records"),
+    offset: int = typer.Option(0, "--offset", help="Offset"),
+):
+    """Show balance change history."""
+    asyncio.run(_history(limit, offset))
+
+
+async def _history(limit: int, offset: int):
+    profile, formatter, api_url, timeout = resolve_context()
+
+    if not require_auth(profile, formatter):
+        raise typer.Exit(1)
+
+    async with O2Client(api_url, timeout) as client:
+        setup_client(client, profile)
+        try:
+            data = await client.get_balance_history(limit, offset)
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)

o2_cli/commands/deposits.py

@@ -0,0 +1,89 @@
+"""o2 deposits commands - Deposit management."""
+
+import asyncio
+
+import typer
+
+from o2_cli.cli import get_state
+from o2_cli.client import O2Client
+from o2_cli.config import load_config, get_active_profile
+from o2_cli.exceptions import APIError, ConnectionError
+from o2_cli.output import OutputFormatter
+
+app = typer.Typer(help="Deposit management")
+
+
+@app.command("address")
+def address(
+    chain: str = typer.Option(
+        "base", "--chain", "-c", help="Blockchain network (base/arbitrum/ethereum)"
+    ),
+):
+    """Get or activate your deposit address."""
+    asyncio.run(_address(chain))
+
+
+async def _address(chain: str):
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    if not profile.token and profile.auth_type == "jwt":
+        formatter.print_error("Not authenticated. Run 'o2 auth test-login' first.")
+        raise typer.Exit(1)
+
+    async with O2Client(api_url, timeout) as client:
+        client.set_jwt(profile.token)
+        if profile.api_key_id:
+            client.set_api_key(profile.api_key_id, profile.api_secret)
+        try:
+            data = await client.get_deposit_address(chain)
+            formatter.print_raw(data)
+            if not state["json_output"]:
+                deposit_addr = data.get("deposit_address", "")
+                if deposit_addr:
+                    formatter.print_success(f"Deposit address: {deposit_addr}")
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("history")
+def history(
+    limit: int = typer.Option(50, "--limit", "-n", help="Number of records"),
+):
+    """Show deposit history."""
+    asyncio.run(_history(limit))
+
+
+async def _history(limit: int):
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    if not profile.token and profile.auth_type == "jwt":
+        formatter.print_error("Not authenticated. Run 'o2 auth test-login' first.")
+        raise typer.Exit(1)
+
+    async with O2Client(api_url, timeout) as client:
+        client.set_jwt(profile.token)
+        if profile.api_key_id:
+            client.set_api_key(profile.api_key_id, profile.api_secret)
+        try:
+            data = await client.get_deposit_history(limit)
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)

o2_cli/commands/fees.py

@@ -0,0 +1,73 @@
+"""o2 fees commands - Fee information."""
+
+import asyncio
+
+import typer
+
+from o2_cli.cli import get_state
+from o2_cli.client import O2Client
+from o2_cli.config import load_config, get_active_profile
+from o2_cli.exceptions import APIError, ConnectionError
+from o2_cli.output import OutputFormatter
+
+app = typer.Typer(help="Fee information")
+
+
+@app.command("rates")
+def rates():
+    """Show current fee rates (public, no auth required)."""
+    asyncio.run(_rates())
+
+
+async def _rates():
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    async with O2Client(api_url, timeout) as client:
+        try:
+            data = await client.get_fee_rates()
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("estimate")
+def estimate(
+    amount: str = typer.Option(..., "--amount", "-a", help="Order amount (base units)"),
+    price: str = typer.Option(..., "--price", "-p", help="Order price"),
+    is_maker: bool = typer.Option(
+        False, "--is-maker", help="Calculate as maker order"
+    ),
+):
+    """Estimate fee for a hypothetical order."""
+    asyncio.run(_estimate(amount, price, is_maker))
+
+
+async def _estimate(amount: str, price: str, is_maker: bool):
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    async with O2Client(api_url, timeout) as client:
+        try:
+            data = await client.estimate_fee(
+                base_amount=amount, price=price, is_maker=is_maker
+            )
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)

o2_cli/commands/markets.py

@@ -0,0 +1,129 @@
+"""o2 markets commands - Market data (public, no auth required)."""
+
+import asyncio
+from typing import Optional
+
+import typer
+
+from o2_cli.cli import get_state
+from o2_cli.client import O2Client
+from o2_cli.config import load_config, get_active_profile
+from o2_cli.exceptions import APIError, ConnectionError
+from o2_cli.output import OutputFormatter
+
+app = typer.Typer(help="Market data")
+
+
+@app.command("list")
+def list_markets():
+    """List all available markets."""
+    asyncio.run(_list_markets())
+
+
+async def _list_markets():
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    async with O2Client(api_url, timeout) as client:
+        try:
+            data = await client.get_markets()
+            formatter.print_markets(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("orderbook")
+def orderbook(
+    market_id: int = typer.Option(..., "--market-id", "-m", help="Market ID"),
+):
+    """Show order book for a market."""
+    asyncio.run(_orderbook(market_id))
+
+
+async def _orderbook(market_id: int):
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    async with O2Client(api_url, timeout) as client:
+        try:
+            data = await client.get_orderbook(market_id)
+            formatter.print_orderbook(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("trades")
+def trades(
+    market_id: int = typer.Option(..., "--market-id", "-m", help="Market ID"),
+    limit: int = typer.Option(50, "--limit", "-n", help="Number of trades"),
+):
+    """Show recent trades for a market."""
+    asyncio.run(_trades(market_id, limit))
+
+
+async def _trades(market_id: int, limit: int):
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    async with O2Client(api_url, timeout) as client:
+        try:
+            data = await client.get_market_trades(market_id, limit)
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)
+
+
+@app.command("candles")
+def candles(
+    market_id: int = typer.Option(..., "--market-id", "-m", help="Market ID"),
+    interval: str = typer.Option(
+        "1h", "--interval", "-i", help="Candle interval (1m/5m/15m/1h/4h/1d)"
+    ),
+    limit: int = typer.Option(500, "--limit", "-n", help="Number of candles"),
+):
+    """Show candlestick data for a market."""
+    asyncio.run(_candles(market_id, interval, limit))
+
+
+async def _candles(market_id: int, interval: str, limit: int):
+    state = get_state()
+    formatter = OutputFormatter(json_mode=state["json_output"])
+    config = load_config()
+    profile = get_active_profile(config)
+    api_url = state.get("api_url") or profile.api_url
+    timeout = state.get("timeout") or profile.timeout
+
+    async with O2Client(api_url, timeout) as client:
+        try:
+            data = await client.get_candles(market_id, interval, limit)
+            formatter.print_raw(data)
+        except APIError as e:
+            formatter.print_error(str(e), e.code)
+            raise typer.Exit(1)
+        except ConnectionError as e:
+            formatter.print_error(str(e))
+            raise typer.Exit(1)