dolomite-cli 1.0.0__tar.gz

dolomite_cli-1.0.0/.gitignore

@@ -0,0 +1,57 @@
+# === Secrets & credentials ===
+.env
+*.env
+**/.env
+**/config.json
+!projects/pokemon-alerts/sku-database.json
+secrets/
+tokens/
+
+# === OpenClaw config (contains API keys) ===
+openclaw.json
+
+# === Temp & cache ===
+__pycache__/
+*.pyc
+*.pyo
+.DS_Store
+*.swp
+*.swo
+*~
+.cache/
+tmp/
+*.tmp
+
+# === Node modules ===
+node_modules/
+
+# === Large binary/media files ===
+*.ogg
+*.wav
+*.mp3
+*.mp4
+*.jpg
+*.jpeg
+*.png
+*.gif
+*.zip
+*.tar.gz
+
+# === Runtime state (changes every poll cycle) ===
+projects/pokemon-alerts/data/poller_state.json
+projects/pokemon-alerts/data/server_comparison.json
+dashboard/pokemon-scan-results.json
+dashboard/pokemon-geocache.json
+memory/heartbeat-state.json
+memory/usage-tracking.json
+
+# === Sensitive memory files ===
+# MEMORY.md contains personal info - keep out of public repos
+# But we want it in private repo for backup
+# (repo is private, so this is fine)
+
+# === Codecks data (contains tokens in practice) ===
+codecks/*.json
+llmrouter-app/
+dg-scan/
+bn_pokemon.json

dolomite_cli-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OpenClaw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dolomite_cli-1.0.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: dolomite-cli
+Version: 1.0.0
+Summary: CLI tool for querying Dolomite protocol data across all chains
+Project-URL: Homepage, https://github.com/openclaw/dolomite-cli
+License-Expression: MIT
+License-File: LICENSE
+Keywords: blockchain,cli,defi,dolomite,interest-rates
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# dolomite CLI
+
+Query Dolomite protocol data across all chains. Returns structured JSON. No API keys required.
+
+## Install
+
+```bash
+pipx install dolomite-cli
+```
+
+Or with pip:
+
+```bash
+pip install dolomite-cli
+```
+
+Requires Python 3.10+. Zero dependencies (stdlib only).
+
+### From source
+
+```bash
+git clone https://github.com/openclaw/dolomite-cli
+cd dolomite-cli
+pip install -e .
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `dolomite rates` | All markets with supply/borrow rates |
+| `dolomite positions` | Top borrowing positions by size |
+| `dolomite flows` | Recent large deposits/withdrawals |
+| `dolomite liquidations` | Recent liquidation events |
+| `dolomite tvl` | Protocol TVL summary per chain |
+| `dolomite markets --token USDC` | Detailed info for a specific token |
+| `dolomite account <address>` | Full position detail for an address |
+| `dolomite risks` | High-risk positions and utilization alerts |
+| `dolomite schema` | Show all commands, chains, entities, examples |
+
+## Examples
+
+```bash
+# Stablecoin rates across all chains
+dolomite rates --stables-only
+
+# Top 20 positions on Ethereum
+dolomite positions --chain ethereum --top 20
+
+# Whale flows in the last 48 hours
+dolomite flows --hours 48 --min-usd 100000
+
+# Deposits only
+dolomite flows --type deposit --hours 72
+
+# Look up a specific whale
+dolomite account 0x8be46b25d59616e594f0a9e20147fb14c1b989d9
+
+# High-risk positions (>80% LTV, >$100K)
+dolomite risks --min-ltv 80 --min-usd 100000
+
+# Berachain rates only
+dolomite rates --chain berachain
+
+# USDC across all chains
+dolomite markets --token USDC
+```
+
+## Output
+
+All commands output JSON to stdout. Errors go to stderr. Pipe to `jq` for filtering:
+
+```bash
+# Top 5 stablecoin rates
+dolomite rates --stables-only | jq '.markets[:5][] | {chain, symbol, supply_rate_pct}'
+
+# Total protocol TVL
+dolomite tvl | jq '.total_supply_usd'
+
+# Addresses with >85% LTV
+dolomite risks --min-ltv 85 | jq '.high_ltv_positions[] | {address, ltv_pct, supply_usd}'
+```
+
+## Chains
+
+| Chain | Chain ID | Status |
+|-------|----------|--------|
+| Ethereum | 1 | Active (~$370M TVL) |
+| Arbitrum | 42161 | Active (~$52M TVL) |
+| Berachain | 80094 | Active (~$50M TVL) |
+| Mantle | 5000 | Minimal |
+| Base | 8453 | Minimal |
+| X Layer | 196 | Minimal |
+
+Default: queries Ethereum, Arbitrum, Berachain. Use `--chain all` for everything.
+
+## Data Sources
+
+- **Subgraph API**: `subgraph.api.dolomite.io` — on-chain positions, flows, liquidations
+- **REST API**: `api.dolomite.io` — token prices, interest rates, market data
+
+No authentication required. All data is public.
+
+## For AI Agents
+
+Run `dolomite schema` to get a complete description of all commands, available entities, and example queries. The output is JSON — parseable by any model.

dolomite_cli-1.0.0/README.md

@@ -0,0 +1,106 @@
+# dolomite CLI
+
+Query Dolomite protocol data across all chains. Returns structured JSON. No API keys required.
+
+## Install
+
+```bash
+pipx install dolomite-cli
+```
+
+Or with pip:
+
+```bash
+pip install dolomite-cli
+```
+
+Requires Python 3.10+. Zero dependencies (stdlib only).
+
+### From source
+
+```bash
+git clone https://github.com/openclaw/dolomite-cli
+cd dolomite-cli
+pip install -e .
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `dolomite rates` | All markets with supply/borrow rates |
+| `dolomite positions` | Top borrowing positions by size |
+| `dolomite flows` | Recent large deposits/withdrawals |
+| `dolomite liquidations` | Recent liquidation events |
+| `dolomite tvl` | Protocol TVL summary per chain |
+| `dolomite markets --token USDC` | Detailed info for a specific token |
+| `dolomite account <address>` | Full position detail for an address |
+| `dolomite risks` | High-risk positions and utilization alerts |
+| `dolomite schema` | Show all commands, chains, entities, examples |
+
+## Examples
+
+```bash
+# Stablecoin rates across all chains
+dolomite rates --stables-only
+
+# Top 20 positions on Ethereum
+dolomite positions --chain ethereum --top 20
+
+# Whale flows in the last 48 hours
+dolomite flows --hours 48 --min-usd 100000
+
+# Deposits only
+dolomite flows --type deposit --hours 72
+
+# Look up a specific whale
+dolomite account 0x8be46b25d59616e594f0a9e20147fb14c1b989d9
+
+# High-risk positions (>80% LTV, >$100K)
+dolomite risks --min-ltv 80 --min-usd 100000
+
+# Berachain rates only
+dolomite rates --chain berachain
+
+# USDC across all chains
+dolomite markets --token USDC
+```
+
+## Output
+
+All commands output JSON to stdout. Errors go to stderr. Pipe to `jq` for filtering:
+
+```bash
+# Top 5 stablecoin rates
+dolomite rates --stables-only | jq '.markets[:5][] | {chain, symbol, supply_rate_pct}'
+
+# Total protocol TVL
+dolomite tvl | jq '.total_supply_usd'
+
+# Addresses with >85% LTV
+dolomite risks --min-ltv 85 | jq '.high_ltv_positions[] | {address, ltv_pct, supply_usd}'
+```
+
+## Chains
+
+| Chain | Chain ID | Status |
+|-------|----------|--------|
+| Ethereum | 1 | Active (~$370M TVL) |
+| Arbitrum | 42161 | Active (~$52M TVL) |
+| Berachain | 80094 | Active (~$50M TVL) |
+| Mantle | 5000 | Minimal |
+| Base | 8453 | Minimal |
+| X Layer | 196 | Minimal |
+
+Default: queries Ethereum, Arbitrum, Berachain. Use `--chain all` for everything.
+
+## Data Sources
+
+- **Subgraph API**: `subgraph.api.dolomite.io` — on-chain positions, flows, liquidations
+- **REST API**: `api.dolomite.io` — token prices, interest rates, market data
+
+No authentication required. All data is public.
+
+## For AI Agents
+
+Run `dolomite schema` to get a complete description of all commands, available entities, and example queries. The output is JSON — parseable by any model.

dolomite_cli-1.0.0/dolomite_cli.py

@@ -0,0 +1,891 @@
+#!/usr/bin/env python3
+"""
+dolomite — CLI tool for querying Dolomite protocol data across all chains.
+
+Provides structured JSON output of rates, positions, flows, liquidations,
+TVL, market details, and account portfolios from Dolomite's subgraphs and APIs.
+
+No API keys required. All data is public on-chain.
+
+Usage:
+    dolomite rates [--chain CHAIN] [--stables-only] [--min-tvl N]
+    dolomite positions [--chain CHAIN] [--top N] [--min-usd N]
+    dolomite flows [--chain CHAIN] [--hours N] [--min-usd N] [--type deposit|withdrawal]
+    dolomite liquidations [--chain CHAIN] [--hours N] [--limit N]
+    dolomite tvl
+    dolomite markets [--token SYMBOL] [--chain CHAIN]
+    dolomite account <address> [--chain CHAIN]
+    dolomite risks [--min-ltv N] [--min-usd N]
+    dolomite schema
+"""
+
+import argparse
+import json
+import sys
+import time
+from datetime import datetime, timezone
+from urllib.request import Request, urlopen
+from urllib.error import HTTPError, URLError
+
+__version__ = "1.0.0"
+
+# ─── Constants ────────────────────────────────────────────────────────────────
+
+SUBGRAPH_BASE = "https://subgraph.api.dolomite.io/api/public/1301d2d1-7a9d-4be4-9e9a-061cb8611549/subgraphs"
+API_BASE = "https://api.dolomite.io"
+
+CHAINS = {
+    "ethereum":  {"name": "Ethereum",  "subgraph": "dolomite-ethereum",           "chain_id": 1},
+    "arbitrum":  {"name": "Arbitrum",  "subgraph": "dolomite-arbitrum",           "chain_id": 42161},
+    "berachain": {"name": "Berachain", "subgraph": "dolomite-berachain-mainnet",  "chain_id": 80094},
+    "mantle":    {"name": "Mantle",    "subgraph": "dolomite-mantle",             "chain_id": 5000},
+    "base":      {"name": "Base",      "subgraph": "dolomite-base",               "chain_id": 8453},
+    "xlayer":    {"name": "X Layer",   "subgraph": "dolomite-x-layer",            "chain_id": 196},
+    "botanix":   {"name": "Botanix",  "subgraph": "dolomite-botanix",            "chain_id": 3637},
+    "polygonzkevm": {"name": "Polygon zkEVM", "subgraph": "dolomite-polygon-zk-evm", "chain_id": 1101},
+}
+
+ACTIVE_CHAINS = ["ethereum", "arbitrum", "berachain", "mantle", "botanix"]  # all chains except X Layer and Polygon zkEVM (older subgraph schema)
+
+STABLECOINS = {
+    "USDC", "USDC.e", "USDT", "DAI", "USD1", "HONEY", "BYUSD",
+    "savUSD", "sDAI", "LUSD", "USD₮0", "rUSD", "MIM", "FRAX"
+}
+
+# ─── Helpers ──────────────────────────────────────────────────────────────────
+
+def _http_json(url, payload=None, timeout=20):
+    """Make an HTTP request and return parsed JSON."""
+    if payload:
+        data = json.dumps(payload).encode("utf-8")
+        req = Request(url, data=data, headers={"Content-Type": "application/json"})
+    else:
+        req = Request(url)
+    try:
+        with urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read())
+    except (HTTPError, URLError, TimeoutError) as e:
+        _err(f"HTTP error: {e}")
+        return {}
+
+
+def _gql(subgraph_name, query, variables=None, timeout=20):
+    """Execute a GraphQL query against a Dolomite subgraph."""
+    url = f"{SUBGRAPH_BASE}/{subgraph_name}/latest/gn"
+    payload = {"query": query}
+    if variables:
+        payload["variables"] = variables
+    result = _http_json(url, payload, timeout)
+    if "errors" in result:
+        _err(f"GraphQL errors: {result['errors']}")
+    return result.get("data", {})
+
+
+def _api(path, timeout=15):
+    """Fetch from Dolomite REST API."""
+    return _http_json(f"{API_BASE}{path}", timeout=timeout)
+
+
+def _out(data):
+    """Print JSON output to stdout."""
+    json.dump(data, sys.stdout, indent=2)
+    sys.stdout.write("\n")
+
+
+def _err(msg):
+    """Print error to stderr."""
+    print(f"error: {msg}", file=sys.stderr)
+
+
+def _resolve_chains(chain_arg):
+    """Resolve --chain argument to list of chain keys."""
+    if chain_arg:
+        key = chain_arg.lower()
+        if key == "all":
+            return list(CHAINS.keys())
+        if key not in CHAINS:
+            _err(f"Unknown chain '{key}'. Available: {', '.join(CHAINS.keys())}")
+            sys.exit(1)
+        return [key]
+    return ACTIVE_CHAINS
+
+
+def _ts_hours_ago(hours):
+    """Return unix timestamp N hours ago."""
+    return int(time.time()) - (hours * 3600)
+
+
+# ─── Commands ─────────────────────────────────────────────────────────────────
+
+def cmd_rates(args):
+    """Fetch all markets with supply/borrow rates across chains."""
+    chains = _resolve_chains(args.chain)
+    min_tvl = args.min_tvl or 1000
+    markets = []
+
+    for chain_key in chains:
+        ci = CHAINS[chain_key]
+        try:
+            tokens_resp = _api(f"/tokens/{ci['chain_id']}")
+            rates_resp = _api(f"/tokens/{ci['chain_id']}/interest-rates")
+            prices_resp = _api(f"/tokens/{ci['chain_id']}/prices")
+
+            tokens = {t["id"]: t for t in tokens_resp.get("tokens", [])}
+            rates = {r["token"]["tokenAddress"]: r for r in rates_resp.get("interestRates", [])}
+            prices = prices_resp.get("prices", {})
+
+            for addr, token in tokens.items():
+                rate = rates.get(addr, {})
+                price = float(prices.get(addr, 0))
+                supply = float(token.get("supplyLiquidity", 0))
+                borrow = float(token.get("borrowLiquidity", 0))
+                supply_rate = float(rate.get("totalSupplyInterestRate", 0)) * 100
+                borrow_rate = float(rate.get("borrowInterestRate", 0)) * 100
+                util = (borrow / supply * 100) if supply > 0 else 0
+                supply_usd = supply * price
+                borrow_usd = borrow * price
+                is_stable = token["symbol"] in STABLECOINS
+
+                if supply_usd < min_tvl:
+                    continue
+                if args.stables_only and not is_stable:
+                    continue
+
+                markets.append({
+                    "chain": ci["name"],
+                    "symbol": token["symbol"],
+                    "supply_rate_pct": round(supply_rate, 3),
+                    "borrow_rate_pct": round(borrow_rate, 3),
+                    "utilization_pct": round(util, 1),
+                    "supply_usd": round(supply_usd),
+                    "borrow_usd": round(borrow_usd),
+                    "price_usd": round(price, 4),
+                    "is_stablecoin": is_stable,
+                })
+        except Exception as e:
+            _err(f"Failed to fetch {ci['name']} rates: {e}")
+
+    markets.sort(key=lambda x: -x["supply_usd"])
+    _out({"timestamp": datetime.now(timezone.utc).isoformat(), "count": len(markets), "markets": markets})
+
+
+def cmd_positions(args):
+    """Fetch top borrowing positions by size."""
+    chains = _resolve_chains(args.chain)
+    top_n = args.top or 50
+    min_usd = args.min_usd or 10000
+    positions = []
+
+    for chain_key in chains:
+        ci = CHAINS[chain_key]
+        try:
+            # Fetch in batches — subgraph max is 1000
+            limit = min(top_n * 2, 1000)  # fetch extra, filter later
+            d = _gql(ci["subgraph"], f"""{{
+                marginAccounts(
+                    where: {{hasBorrowValue: true}}
+                    orderBy: lastUpdatedTimestamp
+                    orderDirection: desc
+                    first: {limit}
+                ) {{
+                    id
+                    effectiveUser {{ id }}
+                    accountNumber
+                    lastUpdatedTimestamp
+                    tokenValues(first: 30) {{
+                        token {{ symbol id }}
+                        valuePar
+                    }}
+                    borrowTokens {{ symbol }}
+                    supplyTokens {{ symbol }}
+                }}
+            }}""", timeout=30)
+
+            prices = _api(f"/tokens/{ci['chain_id']}/prices").get("prices", {})
+
+            for acct in d.get("marginAccounts", []):
+                supply_usd = 0
+                borrow_usd = 0
+                position_detail = []
+
+                for tv in acct["tokenValues"]:
+                    val = float(tv["valuePar"])
+                    price = float(prices.get(tv["token"]["id"], 0))
+                    usd = val * price
+                    if val > 0:
+                        supply_usd += usd
+                    else:
+                        borrow_usd += abs(usd)
+                    if abs(usd) > 100:
+                        position_detail.append({
+                            "token": tv["token"]["symbol"],
+                            "amount": round(val, 4),
+                            "usd": round(usd, 2),
+                        })
+
+                if supply_usd < min_usd and borrow_usd < min_usd:
+                    continue
+
+                ltv = (borrow_usd / supply_usd * 100) if supply_usd > 0 else 0
+                positions.append({
+                    "chain": ci["name"],
+                    "address": acct["effectiveUser"]["id"],
+                    "account_number": acct["accountNumber"],
+                    "supply_usd": round(supply_usd),
+                    "borrow_usd": round(borrow_usd),
+                    "net_usd": round(supply_usd - borrow_usd),
+                    "ltv_pct": round(ltv, 1),
+                    "supply_tokens": [t["symbol"] for t in acct["supplyTokens"]],
+                    "borrow_tokens": [t["symbol"] for t in acct["borrowTokens"]],
+                    "positions": position_detail,
+                    "last_active": int(acct["lastUpdatedTimestamp"]),
+                })
+        except Exception as e:
+            _err(f"Failed to fetch {ci['name']} positions: {e}")
+
+    positions.sort(key=lambda x: -x["supply_usd"])
+    positions = positions[:top_n]
+    _out({"timestamp": datetime.now(timezone.utc).isoformat(), "count": len(positions), "positions": positions})
+
+
+def cmd_flows(args):
+    """Fetch recent large deposits and withdrawals."""
+    chains = _resolve_chains(args.chain)
+    hours = args.hours or 24
+    min_usd = args.min_usd or 50000
+    flow_type = args.type  # deposit, withdrawal, or None (both)
+    ts_floor = _ts_hours_ago(hours)
+    flows = []
+
+    for chain_key in chains:
+        ci = CHAINS[chain_key]
+        try:
+            queries = []
+            if flow_type != "withdrawal":
+                queries.append(("deposit", f"""{{
+                    deposits(
+                        orderBy: serialId, orderDirection: desc, first: 100,
+                        where: {{amountUSDDeltaWei_gte: "{min_usd}"}}
+                    ) {{
+                        transaction {{ timestamp blockNumber }}
+                        marginAccount {{ effectiveUser {{ id }} }}
+                        token {{ symbol }}
+                        amountDeltaWei
+                        amountUSDDeltaWei
+                    }}
+                }}"""))
+            if flow_type != "deposit":
+                queries.append(("withdrawal", f"""{{
+                    withdrawals(
+                        orderBy: serialId, orderDirection: desc, first: 100,
+                        where: {{amountUSDDeltaWei_gte: "{min_usd}"}}
+                    ) {{
+                        transaction {{ timestamp blockNumber }}
+                        marginAccount {{ effectiveUser {{ id }} }}
+                        token {{ symbol }}
+                        amountDeltaWei
+                        amountUSDDeltaWei
+                    }}
+                }}"""))
+
+            for ftype, query in queries:
+                d = _gql(ci["subgraph"], query, timeout=20)
+                entity_key = "deposits" if ftype == "deposit" else "withdrawals"
+                for item in d.get(entity_key, []):
+                    ts = int(item["transaction"]["timestamp"])
+                    if ts < ts_floor:
+                        continue
+                    flows.append({
+                        "type": ftype,
+                        "chain": ci["name"],
+                        "address": item["marginAccount"]["effectiveUser"]["id"],
+                        "token": item["token"]["symbol"],
+                        "amount": round(float(item["amountDeltaWei"]), 4),
+                        "usd": round(float(item["amountUSDDeltaWei"])),
+                        "timestamp": ts,
+                        "block": int(item["transaction"]["blockNumber"]),
+                        "time": datetime.fromtimestamp(ts, tz=timezone.utc).isoformat(),
+                    })
+        except Exception as e:
+            _err(f"Failed to fetch {ci['name']} flows: {e}")
+
+    flows.sort(key=lambda x: -x["timestamp"])
+    _out({
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "period_hours": hours,
+        "min_usd": min_usd,
+        "count": len(flows),
+        "flows": flows,
+    })
+
+
+def cmd_liquidations(args):
+    """Fetch recent liquidation events."""
+    chains = _resolve_chains(args.chain)
+    hours = args.hours or 168  # default 7 days
+    limit = args.limit or 100
+    ts_floor = _ts_hours_ago(hours)
+    liquidations = []
+
+    for chain_key in chains:
+        ci = CHAINS[chain_key]
+        try:
+            d = _gql(ci["subgraph"], f"""{{
+                liquidations(
+                    orderBy: serialId, orderDirection: desc, first: {min(limit, 200)}
+                ) {{
+                    transaction {{ timestamp blockNumber }}
+                    solidMarginAccount {{ effectiveUser {{ id }} }}
+                    liquidMarginAccount {{ effectiveUser {{ id }} }}
+                    heldToken {{ symbol }}
+                    borrowedToken {{ symbol }}
+                    heldTokenAmountDeltaWei
+                    borrowedTokenAmountDeltaWei
+                    heldTokenAmountUSD
+                    borrowedTokenAmountUSD
+                    heldTokenLiquidationRewardWei
+                    heldTokenLiquidationRewardUSD
+                }}
+            }}""", timeout=20)
+
+            prices = _api(f"/tokens/{ci['chain_id']}/prices").get("prices", {})
+
+            for liq in d.get("liquidations", []):
+                ts = int(liq["transaction"]["timestamp"])
+                if ts < ts_floor:
+                    continue
+                liquidations.append({
+                    "chain": ci["name"],
+                    "liquidated_address": liq["liquidMarginAccount"]["effectiveUser"]["id"],
+                    "liquidator_address": liq["solidMarginAccount"]["effectiveUser"]["id"],
+                    "held_token": liq["heldToken"]["symbol"],
+                    "borrowed_token": liq["borrowedToken"]["symbol"],
+                    "held_usd": round(float(liq.get("heldTokenAmountUSD", 0)), 2),
+                    "borrowed_usd": round(float(liq.get("borrowedTokenAmountUSD", 0)), 2),
+                    "reward_usd": round(float(liq.get("heldTokenLiquidationRewardUSD", 0)), 2),
+                    "timestamp": ts,
+                    "block": int(liq["transaction"]["blockNumber"]),
+                    "time": datetime.fromtimestamp(ts, tz=timezone.utc).isoformat(),
+                })
+        except Exception as e:
+            _err(f"Failed to fetch {ci['name']} liquidations: {e}")
+
+    liquidations.sort(key=lambda x: -x["timestamp"])
+    _out({
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "period_hours": hours,
+        "count": len(liquidations),
+        "liquidations": liquidations,
+    })
+
+
+def cmd_tvl(args):
+    """Fetch protocol-level TVL summary per chain."""
+    chains = _resolve_chains(getattr(args, 'chain', None))
+    summary = {}
+
+    for chain_key in chains:
+        ci = CHAINS[chain_key]
+        try:
+            d = _gql(ci["subgraph"], """{
+                dolomiteMargins(first: 1) {
+                    supplyLiquidityUSD borrowLiquidityUSD userCount
+                    totalTradeVolumeUSD totalLiquidationVolumeUSD
+                    liquidationCount borrowPositionCount numberOfMarkets
+                }
+            }""")
+            margin = d["dolomiteMargins"][0]
+            supply = float(margin["supplyLiquidityUSD"])
+            borrow = float(margin["borrowLiquidityUSD"])
+            summary[ci["name"]] = {
+                "supply_usd": round(supply),
+                "borrow_usd": round(borrow),
+                "utilization_pct": round(borrow / supply * 100, 1) if supply > 0 else 0,
+                "users": int(margin["userCount"]),
+                "markets": margin["numberOfMarkets"],
+                "borrow_positions": int(margin["borrowPositionCount"]),
+                "total_trade_volume_usd": round(float(margin["totalTradeVolumeUSD"])),
+                "total_liquidation_volume_usd": round(float(margin["totalLiquidationVolumeUSD"])),
+                "liquidation_count": int(margin["liquidationCount"]),
+            }
+        except Exception as e:
+            _err(f"Failed to fetch {ci['name']} TVL: {e}")
+
+    total_supply = sum(v["supply_usd"] for v in summary.values())
+    total_borrow = sum(v["borrow_usd"] for v in summary.values())
+    total_users = sum(v["users"] for v in summary.values())
+
+    _out({
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "total_supply_usd": total_supply,
+        "total_borrow_usd": total_borrow,
+        "total_utilization_pct": round(total_borrow / total_supply * 100, 1) if total_supply > 0 else 0,
+        "total_users": total_users,
+        "chains": summary,
+    })
+
+
+def cmd_markets(args):
+    """Fetch detailed info for a specific token across chains."""
+    chains = _resolve_chains(args.chain)
+    target = args.token.upper() if args.token else None
+    results = []
+
+    for chain_key in chains:
+        ci = CHAINS[chain_key]
+        try:
+            tokens_resp = _api(f"/tokens/{ci['chain_id']}")
+            rates_resp = _api(f"/tokens/{ci['chain_id']}/interest-rates")
+            prices_resp = _api(f"/tokens/{ci['chain_id']}/prices")
+
+            tokens = {t["id"]: t for t in tokens_resp.get("tokens", [])}
+            rates = {r["token"]["tokenAddress"]: r for r in rates_resp.get("interestRates", [])}
+            prices = prices_resp.get("prices", {})
+
+            for addr, token in tokens.items():
+                if target and token["symbol"].upper() != target:
+                    continue
+                rate = rates.get(addr, {})
+                price = float(prices.get(addr, 0))
+                supply = float(token.get("supplyLiquidity", 0))
+                borrow = float(token.get("borrowLiquidity", 0))
+                supply_rate = float(rate.get("totalSupplyInterestRate", 0)) * 100
+                borrow_rate = float(rate.get("borrowInterestRate", 0)) * 100
+                util = (borrow / supply * 100) if supply > 0 else 0
+
+                results.append({
+                    "chain": ci["name"],
+                    "symbol": token["symbol"],
+                    "address": addr,
+                    "price_usd": round(price, 6),
+                    "supply_rate_pct": round(supply_rate, 3),
+                    "borrow_rate_pct": round(borrow_rate, 3),
+                    "utilization_pct": round(util, 1),
+                    "supply_amount": round(supply, 4),
+                    "supply_usd": round(supply * price),
+                    "borrow_amount": round(borrow, 4),
+                    "borrow_usd": round(borrow * price),
+                    "available_amount": round(supply - borrow, 4),
+                    "available_usd": round((supply - borrow) * price),
+                })
+        except Exception as e:
+            _err(f"Failed to fetch {ci['name']} markets: {e}")
+
+    results.sort(key=lambda x: -x["supply_usd"])
+    _out({"timestamp": datetime.now(timezone.utc).isoformat(), "count": len(results), "markets": results})
+
+
+def cmd_account(args):
+    """Fetch full position detail for a specific address."""
+    address = args.address.lower()
+    chains = _resolve_chains(args.chain)
+    account_data = {
+        "address": address,
+        "chains": {},
+        "total_supply_usd": 0,
+        "total_borrow_usd": 0,
+        "total_net_usd": 0,
+    }
+
+    for chain_key in chains:
+        ci = CHAINS[chain_key]
+        try:
+            prices = _api(f"/tokens/{ci['chain_id']}/prices").get("prices", {})
+
+            # Get all margin accounts for this user
+            d = _gql(ci["subgraph"], """
+            query($user: String!) {
+                marginAccounts(where: {effectiveUser: $user}, first: 50) {
+                    id
+                    accountNumber
+                    lastUpdatedTimestamp
+                    hasBorrowValue
+                    tokenValues(first: 30) {
+                        token { id symbol }
+                        valuePar
+                    }
+                    borrowTokens { symbol }
+                    supplyTokens { symbol }
+                }
+            }
+            """, {"user": address}, timeout=20)
+
+            accounts = []
+            chain_supply = 0
+            chain_borrow = 0
+
+            for acct in d.get("marginAccounts", []):
+                supply_usd = 0
+                borrow_usd = 0
+                holdings = []
+
+                for tv in acct["tokenValues"]:
+                    val = float(tv["valuePar"])
+                    if abs(val) < 0.0001:
+                        continue
+                    price = float(prices.get(tv["token"]["id"], 0))
+                    usd = val * price
+                    if val > 0:
+                        supply_usd += usd
+                    else:
+                        borrow_usd += abs(usd)
+                    holdings.append({
+                        "token": tv["token"]["symbol"],
+                        "amount": round(val, 6),
+                        "usd": round(usd, 2),
+                        "side": "supply" if val > 0 else "borrow",
+                    })
+
+                if not holdings:
+                    continue
+
+                ltv = (borrow_usd / supply_usd * 100) if supply_usd > 0 else 0
+                chain_supply += supply_usd
+                chain_borrow += borrow_usd
+
+                accounts.append({
+                    "account_number": acct["accountNumber"],
+                    "has_borrow": acct["hasBorrowValue"],
+                    "supply_usd": round(supply_usd),
+                    "borrow_usd": round(borrow_usd),
+                    "net_usd": round(supply_usd - borrow_usd),
+                    "ltv_pct": round(ltv, 1),
+                    "last_active": int(acct["lastUpdatedTimestamp"]),
+                    "last_active_time": datetime.fromtimestamp(int(acct["lastUpdatedTimestamp"]), tz=timezone.utc).isoformat(),
+                    "holdings": sorted(holdings, key=lambda h: -abs(h["usd"])),
+                })
+
+            if accounts:
+                account_data["chains"][ci["name"]] = {
+                    "supply_usd": round(chain_supply),
+                    "borrow_usd": round(chain_borrow),
+                    "net_usd": round(chain_supply - chain_borrow),
+                    "accounts": sorted(accounts, key=lambda a: -a["supply_usd"]),
+                }
+                account_data["total_supply_usd"] += round(chain_supply)
+                account_data["total_borrow_usd"] += round(chain_borrow)
+
+            # Also fetch recent activity
+            flows = _gql(ci["subgraph"], """
+            query($user: String!) {
+                deposits(
+                    where: {marginAccount_: {effectiveUser: $user}}
+                    orderBy: serialId, orderDirection: desc, first: 10
+                ) {
+                    transaction { timestamp }
+                    token { symbol }
+                    amountDeltaWei
+                    amountUSDDeltaWei
+                }
+                withdrawals(
+                    where: {marginAccount_: {effectiveUser: $user}}
+                    orderBy: serialId, orderDirection: desc, first: 10
+                ) {
+                    transaction { timestamp }
+                    token { symbol }
+                    amountDeltaWei
+                    amountUSDDeltaWei
+                }
+            }
+            """, {"user": address}, timeout=20)
+
+            recent_activity = []
+            for dep in flows.get("deposits", []):
+                usd = float(dep["amountUSDDeltaWei"])
+                if usd < 100:
+                    continue
+                recent_activity.append({
+                    "type": "deposit",
+                    "chain": ci["name"],
+                    "token": dep["token"]["symbol"],
+                    "amount": round(float(dep["amountDeltaWei"]), 4),
+                    "usd": round(usd),
+                    "timestamp": int(dep["transaction"]["timestamp"]),
+                    "time": datetime.fromtimestamp(int(dep["transaction"]["timestamp"]), tz=timezone.utc).isoformat(),
+                })
+            for wd in flows.get("withdrawals", []):
+                usd = float(wd["amountUSDDeltaWei"])
+                if usd < 100:
+                    continue
+                recent_activity.append({
+                    "type": "withdrawal",
+                    "chain": ci["name"],
+                    "token": wd["token"]["symbol"],
+                    "amount": round(float(wd["amountDeltaWei"]), 4),
+                    "usd": round(usd),
+                    "timestamp": int(wd["transaction"]["timestamp"]),
+                    "time": datetime.fromtimestamp(int(wd["transaction"]["timestamp"]), tz=timezone.utc).isoformat(),
+                })
+
+            if recent_activity:
+                recent_activity.sort(key=lambda x: -x["timestamp"])
+                if ci["name"] in account_data["chains"]:
+                    account_data["chains"][ci["name"]]["recent_activity"] = recent_activity
+
+        except Exception as e:
+            _err(f"Failed to fetch {ci['name']} account: {e}")
+
+    account_data["total_net_usd"] = account_data["total_supply_usd"] - account_data["total_borrow_usd"]
+    account_data["timestamp"] = datetime.now(timezone.utc).isoformat()
+    account_data["debank_url"] = f"https://debank.com/profile/{address}"
+    _out(account_data)
+
+
+def cmd_risks(args):
+    """Identify high-risk positions and dangerous utilization levels."""
+    min_ltv = args.min_ltv or 75
+    min_usd = args.min_usd or 50000
+    risks = {
+        "high_ltv_positions": [],
+        "high_utilization_markets": [],
+    }
+
+    # Get positions across all chains
+    for chain_key in ACTIVE_CHAINS:
+        ci = CHAINS[chain_key]
+        try:
+            d = _gql(ci["subgraph"], """{
+                marginAccounts(
+                    where: {hasBorrowValue: true}
+                    orderBy: lastUpdatedTimestamp
+                    orderDirection: desc
+                    first: 200
+                ) {
+                    effectiveUser { id }
+                    accountNumber
+                    tokenValues(first: 30) {
+                        token { symbol id }
+                        valuePar
+                    }
+                    supplyTokens { symbol }
+                    borrowTokens { symbol }
+                }
+            }""", timeout=30)
+
+            prices = _api(f"/tokens/{ci['chain_id']}/prices").get("prices", {})
+
+            for acct in d.get("marginAccounts", []):
+                supply_usd = 0
+                borrow_usd = 0
+                for tv in acct["tokenValues"]:
+                    val = float(tv["valuePar"])
+                    price = float(prices.get(tv["token"]["id"], 0))
+                    if val > 0:
+                        supply_usd += val * price
+                    else:
+                        borrow_usd += abs(val * price)
+
+                if supply_usd < min_usd:
+                    continue
+                ltv = (borrow_usd / supply_usd * 100) if supply_usd > 0 else 0
+                if ltv >= min_ltv:
+                    risks["high_ltv_positions"].append({
+                        "chain": ci["name"],
+                        "address": acct["effectiveUser"]["id"],
+                        "supply_usd": round(supply_usd),
+                        "borrow_usd": round(borrow_usd),
+                        "ltv_pct": round(ltv, 1),
+                        "supply_tokens": [t["symbol"] for t in acct["supplyTokens"]],
+                        "borrow_tokens": [t["symbol"] for t in acct["borrowTokens"]],
+                    })
+        except Exception as e:
+            _err(f"Failed to fetch {ci['name']} risk positions: {e}")
+
+    # Check market utilization
+    for chain_key in ACTIVE_CHAINS:
+        ci = CHAINS[chain_key]
+        try:
+            tokens_resp = _api(f"/tokens/{ci['chain_id']}")
+            rates_resp = _api(f"/tokens/{ci['chain_id']}/interest-rates")
+            prices_resp = _api(f"/tokens/{ci['chain_id']}/prices")
+
+            tokens = {t["id"]: t for t in tokens_resp.get("tokens", [])}
+            rates = {r["token"]["tokenAddress"]: r for r in rates_resp.get("interestRates", [])}
+            prices = prices_resp.get("prices", {})
+
+            for addr, token in tokens.items():
+                price = float(prices.get(addr, 0))
+                supply = float(token.get("supplyLiquidity", 0))
+                borrow = float(token.get("borrowLiquidity", 0))
+                supply_usd = supply * price
+                if supply_usd < 10000:
+                    continue
+                util = (borrow / supply * 100) if supply > 0 else 0
+                if util >= 80:
+                    rate = rates.get(addr, {})
+                    risks["high_utilization_markets"].append({
+                        "chain": ci["name"],
+                        "symbol": token["symbol"],
+                        "utilization_pct": round(util, 1),
+                        "supply_usd": round(supply_usd),
+                        "borrow_usd": round(borrow * price),
+                        "available_usd": round((supply - borrow) * price),
+                        "supply_rate_pct": round(float(rate.get("totalSupplyInterestRate", 0)) * 100, 3),
+                        "borrow_rate_pct": round(float(rate.get("borrowInterestRate", 0)) * 100, 3),
+                    })
+        except Exception as e:
+            _err(f"Failed to fetch {ci['name']} market risks: {e}")
+
+    risks["high_ltv_positions"].sort(key=lambda x: -x["ltv_pct"])
+    risks["high_utilization_markets"].sort(key=lambda x: -x["utilization_pct"])
+    risks["timestamp"] = datetime.now(timezone.utc).isoformat()
+    risks["thresholds"] = {"min_ltv_pct": min_ltv, "min_position_usd": min_usd, "min_utilization_pct": 80}
+    _out(risks)
+
+
+def cmd_schema(args):
+    """Show available subgraph entities and example queries."""
+    _out({
+        "description": "Dolomite CLI — query Dolomite protocol data across all chains",
+        "version": __version__,
+        "subgraph_base": SUBGRAPH_BASE,
+        "api_base": API_BASE,
+        "chains": {k: {"name": v["name"], "chain_id": v["chain_id"], "subgraph": v["subgraph"]} for k, v in CHAINS.items()},
+        "active_chains": ACTIVE_CHAINS,
+        "commands": {
+            "rates": "All markets with supply/borrow rates. Options: --chain, --stables-only, --min-tvl",
+            "positions": "Top borrowing positions. Options: --chain, --top N, --min-usd N",
+            "flows": "Recent large deposits/withdrawals. Options: --chain, --hours N, --min-usd N, --type deposit|withdrawal",
+            "liquidations": "Recent liquidation events. Options: --chain, --hours N, --limit N",
+            "tvl": "Protocol-level TVL summary per chain",
+            "markets": "Detailed info for a specific token. Options: --token SYMBOL, --chain",
+            "account": "Full position detail for an address. Args: <address>. Options: --chain",
+            "risks": "High-risk positions and dangerous utilization. Options: --min-ltv N, --min-usd N",
+            "schema": "This help message with available entities and example queries",
+        },
+        "key_subgraph_entities": [
+            "DolomiteMargin — protocol-level aggregates (TVL, users, volumes)",
+            "Token — listed assets with addresses and metadata",
+            "MarginAccount — user positions with tokenValues (supply/borrow per asset)",
+            "BorrowPosition — individual borrow positions with status",
+            "Deposit — deposit events with amounts, timestamps, users",
+            "Withdrawal — withdrawal events with amounts, timestamps, users",
+            "Liquidation — liquidation events with seized collateral and debt",
+            "Trade — trade/swap events within margin accounts",
+            "AmmLiquidity* — AMM pool data (AmmLiquidityPosition, AmmLiquiditySnapshot)",
+        ],
+        "example_queries": {
+            "get_all_rates": "dolomite rates",
+            "stablecoin_rates_only": "dolomite rates --stables-only",
+            "ethereum_positions": "dolomite positions --chain ethereum --top 20",
+            "whale_flows_48h": "dolomite flows --hours 48 --min-usd 100000",
+            "deposits_only": "dolomite flows --type deposit --hours 72",
+            "specific_token": "dolomite markets --token USDC",
+            "lookup_whale": "dolomite account 0x8be46b25d59616e594f0a9e20147fb14c1b989d9",
+            "high_risk": "dolomite risks --min-ltv 80 --min-usd 100000",
+            "berachain_only": "dolomite rates --chain berachain",
+        },
+        "custom_queries": {
+            "description": "The CLI commands are convenience wrappers. You can also query the Dolomite subgraphs directly via GraphQL for ANY data not covered by the built-in commands. The subgraphs contain the COMPLETE on-chain history — every deposit, withdrawal, liquidation, trade, position change, and margin account update since deployment. There are NO time limits or data caps.",
+            "subgraph_url_pattern": "POST https://subgraph.api.dolomite.io/api/public/1301d2d1-7a9d-4be4-9e9a-061cb8611549/subgraphs/{subgraph_name}/latest/gn",
+            "subgraph_names": {
+                "ethereum": "dolomite-ethereum",
+                "arbitrum": "dolomite-arbitrum",
+                "berachain": "dolomite-berachain-mainnet",
+                "mantle": "dolomite-mantle",
+                "base": "dolomite-base",
+                "xlayer": "dolomite-x-layer"
+            },
+            "auth": "None required. All endpoints are public.",
+            "how_to_query": "Send a POST request with JSON body: {\"query\": \"{ ... }\", \"variables\": {...}}. Returns {\"data\": {...}}.",
+            "pagination": "Subgraph max is 1000 items per query. Use 'first: N, skip: M' or cursor-based pagination with 'where: {id_gt: lastId}' for larger datasets.",
+            "introspection": "Run this to discover all entity types and fields: {\"query\": \"{__schema{types{name fields{name type{name}}}}}\"}. Or for a single entity: {\"query\": \"{__type(name:\\\"Deposit\\\"){fields{name type{name}}}}\"}",
+            "example_custom_queries": {
+                "all_deposits_by_address_all_time": "curl -s -X POST '{subgraph_url}' -H 'Content-Type: application/json' -d '{\"query\": \"{deposits(where: {marginAccount_: {effectiveUser: \\\"0xADDRESS\\\"}}, orderBy: serialId, orderDirection: desc, first: 1000) { transaction { timestamp } token { symbol } amountDeltaWei amountUSDDeltaWei }}\"}'",
+                "trades_in_last_30_days": "curl -s -X POST '{subgraph_url}' -H 'Content-Type: application/json' -d '{\"query\": \"{trades(where: {transaction_: {timestamp_gte: UNIX_30_DAYS_AGO}}, orderBy: serialId, orderDirection: desc, first: 100) { transaction { timestamp } makerToken { symbol } takerToken { symbol } makerTokenDeltaWei takerTokenDeltaWei }}\"}'",
+                "total_protocol_stats": "curl -s -X POST '{subgraph_url}' -H 'Content-Type: application/json' -d '{\"query\": \"{dolomiteMargins(first:1) { supplyLiquidityUSD borrowLiquidityUSD userCount totalTradeVolumeUSD totalLiquidationVolumeUSD liquidationCount borrowPositionCount numberOfMarkets }}\"}'",
+                "all_borrow_positions_for_token": "curl -s -X POST '{subgraph_url}' -H 'Content-Type: application/json' -d '{\"query\": \"{borrowPositions(where: {borrowToken_: {symbol: \\\"USDC\\\"}, status: Open}, first: 100, orderBy: amounts__borrowAmountUSD, orderDirection: desc) { effectiveUser { id } amounts { borrowAmountUSD supplyAmountUSD } }}\"}'",
+                "margin_account_full_detail": "curl -s -X POST '{subgraph_url}' -H 'Content-Type: application/json' -d '{\"query\": \"{marginAccounts(where: {effectiveUser: \\\"0xADDRESS\\\"}, first: 50) { id accountNumber lastUpdatedTimestamp hasBorrowValue tokenValues(first: 30) { token { symbol id } valuePar } supplyTokens { symbol } borrowTokens { symbol } }}\"}'"
+            },
+            "rest_api": {
+                "description": "Dolomite also has a REST API for real-time prices, interest rates, and token metadata.",
+                "base_url": "https://api.dolomite.io",
+                "endpoints": {
+                    "tokens": "/tokens/{chainId} — all listed tokens with supply/borrow amounts",
+                    "interest_rates": "/tokens/{chainId}/interest-rates — current supply and borrow interest rates",
+                    "prices": "/tokens/{chainId}/prices — current USD prices for all tokens"
+                },
+                "chain_ids": {"ethereum": 1, "arbitrum": 42161, "berachain": 80094, "mantle": 5000, "base": 8453, "xlayer": 196}
+            }
+        },
+    })
+
+
+# ─── CLI Setup ────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="dolomite",
+        description="Query Dolomite protocol data across all chains. Returns structured JSON.",
+    )
+    parser.add_argument("--version", action="version", version=f"dolomite {__version__}")
+    sub = parser.add_subparsers(dest="command", help="Available commands")
+
+    # rates
+    p = sub.add_parser("rates", help="All markets with supply/borrow rates")
+    p.add_argument("--chain", help="Filter by chain (ethereum, arbitrum, berachain, all)")
+    p.add_argument("--stables-only", action="store_true", help="Only show stablecoin markets")
+    p.add_argument("--min-tvl", type=float, help="Minimum TVL in USD (default: 1000)")
+
+    # positions
+    p = sub.add_parser("positions", help="Top borrowing positions")
+    p.add_argument("--chain", help="Filter by chain")
+    p.add_argument("--top", type=int, help="Number of positions to return (default: 50)")
+    p.add_argument("--min-usd", type=float, help="Minimum position size in USD (default: 10000)")
+
+    # flows
+    p = sub.add_parser("flows", help="Recent large deposits/withdrawals")
+    p.add_argument("--chain", help="Filter by chain")
+    p.add_argument("--hours", type=int, help="Lookback period in hours (default: 24)")
+    p.add_argument("--min-usd", type=float, help="Minimum flow size in USD (default: 50000)")
+    p.add_argument("--type", choices=["deposit", "withdrawal"], help="Filter by flow type")
+
+    # liquidations
+    p = sub.add_parser("liquidations", help="Recent liquidation events")
+    p.add_argument("--chain", help="Filter by chain")
+    p.add_argument("--hours", type=int, help="Lookback period in hours (default: 168 = 7 days)")
+    p.add_argument("--limit", type=int, help="Max events to return (default: 100)")
+
+    # tvl
+    p = sub.add_parser("tvl", help="Protocol TVL summary per chain")
+    p.add_argument("--chain", help="Filter by chain")
+
+    # markets
+    p = sub.add_parser("markets", help="Detailed info for a specific token")
+    p.add_argument("--token", help="Token symbol (e.g., USDC, WETH)")
+    p.add_argument("--chain", help="Filter by chain")
+
+    # account
+    p = sub.add_parser("account", help="Full position detail for an address")
+    p.add_argument("address", help="Ethereum address (0x...)")
+    p.add_argument("--chain", help="Filter by chain")
+
+    # risks
+    p = sub.add_parser("risks", help="High-risk positions and utilization alerts")
+    p.add_argument("--min-ltv", type=float, help="Minimum LTV to flag (default: 75)")
+    p.add_argument("--min-usd", type=float, help="Minimum position size (default: 50000)")
+
+    # schema
+    sub.add_parser("schema", help="Show available data and example queries")
+
+    args = parser.parse_args()
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    cmd_map = {
+        "rates": cmd_rates,
+        "positions": cmd_positions,
+        "flows": cmd_flows,
+        "liquidations": cmd_liquidations,
+        "tvl": cmd_tvl,
+        "markets": cmd_markets,
+        "account": cmd_account,
+        "risks": cmd_risks,
+        "schema": cmd_schema,
+    }
+    cmd_map[args.command](args)
+
+
+if __name__ == "__main__":
+    main()

dolomite_cli-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dolomite-cli"
+version = "1.0.0"
+description = "CLI tool for querying Dolomite protocol data across all chains"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+keywords = ["dolomite", "defi", "cli", "blockchain", "interest-rates"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Office/Business :: Financial",
+]
+
+[project.scripts]
+dolomite = "dolomite_cli:main"
+
+[project.urls]
+Homepage = "https://github.com/openclaw/dolomite-cli"