Créer un dashboard d’analyse Hyperliquid : du zéro au cas pratique
Pour un trader actif sur Hyperliquid ou un chercheur quant, disposer d’un dashboard personnel mis à jour en temps réel peut fortement améliorer la lecture du marché et la prise de décision. Dans ce guide, tu vas construire un tableau de bord Hyperliquid couvrant le suivi des positions, les funding rates et l’analyse du PnL, de la collecte de données jusqu’à la visualisation front-end, avec des outils open source et sans abonnement supplémentaire.
Quels modules inclure dans un dashboard Hyperliquid ?
Un dashboard Hyperliquid vraiment utile doit généralement couvrir plusieurs blocs clés :
- Vue d’ensemble du compte : valeur du compte, marge disponible, levier utilisé
- Suivi des positions : actif, sens long/short, taille, prix d’entrée, PnL latent
- Funding rates : historique, évolution par actif, détection de niveaux anormaux
- Données de marché : prix, carnets d’ordres, derniers trades
- Alertes : seuils de funding, variation du PnL, niveau de marge, exposition excessive
La documentation officielle Hyperliquid liste les différents types d’Info Endpoints disponibles.
Choix de la stack technique
Stack open source recommandée :
- Collecte de données backend : Python +
requests, ouaiohttppour une version asynchrone - Stockage : SQLite pour un usage local léger, ou PostgreSQL + TimescaleDB pour les données temporelles
- Framework de dashboard : Grafana, robuste et compatible avec SQLite/Postgres, ou Streamlit, natif Python et très pratique pour prototyper vite
- Temps réel : API WebSocket Hyperliquid
Pour valider rapidement une idée, Streamlit est souvent le meilleur choix. Pour un monitoring plus durable, collaboratif ou proche d’un environnement de production, Grafana + TimescaleDB sera plus solide.
Implémenter la couche de collecte de données
Collecte de l’état du compte
import requests
import time
ENDPOINT = "https://api.hyperliquid.xyz/info"
def fetch_account_state(address: str) -> dict:
payload = {"type": "clearinghouseState", "user": address}
r = requests.post(ENDPOINT, json=payload, timeout=10)
r.raise_for_status()
return r.json()
def fetch_market_data() -> dict:
payload = {"type": "metaAndAssetCtxs"}
r = requests.post(ENDPOINT, json=payload, timeout=10)
r.raise_for_status()
return r.json()
Collecte groupée des funding rates
def fetch_all_funding_rates(coins: list, days: int = 1) -> dict:
end_ms = int(time.time() * 1000)
start_ms = end_ms - days * 24 * 3600 * 1000
results = {}
for coin in coins:
payload = {
"type": "fundingHistory",
"coin": coin,
"startTime": start_ms,
}
r = requests.post(ENDPOINT, json=payload, timeout=10)
if r.ok:
results[coin] = r.json()
return results
Abonnement WebSocket en temps réel
Pour afficher un carnet d’ordres ou les derniers trades en temps réel, utilise l’interface WebSocket d’Hyperliquid :
import asyncio
import websockets
import json
WS_URL = "wss://api.hyperliquid.xyz/ws"
async def subscribe_trades(coin: str):
async with websockets.connect(WS_URL) as ws:
sub_msg = {
"method": "subscribe",
"subscription": {"type": "trades", "coin": coin}
}
await ws.send(json.dumps(sub_msg))
while True:
msg = await ws.recv()
data = json.loads(msg)
print(data)
asyncio.run(subscribe_trades("BTC"))
Les types d’abonnement WebSocket sont détaillés dans la section WebSocket de la documentation officielle Hyperliquid.
Construire l’interface du dashboard avec Streamlit
import streamlit as st
import pandas as pd
import plotly.express as px
st.set_page_config(page_title="Hyperliquid Dashboard", layout="wide")
ADDRESS = st.sidebar.text_input("Adresse du wallet", value="0x...")
if ADDRESS.startswith("0x"):
state = fetch_account_state(ADDRESS)
margin = state.get("marginSummary", {})
col1, col2, col3 = st.columns(3)
col1.metric("Valeur du compte (USDC)", f"${float(margin.get('accountValue', 0)):,.2f}")
col2.metric("Marge disponible", f"${float(margin.get('withdrawable', 0)):,.2f}")
col3.metric(
"Levier",
f"{float(margin.get('totalRawUsd', 0)) / max(float(margin.get('accountValue', 1)), 1):.1f}x"
)
positions = state.get("assetPositions", [])
if positions:
pos_data = []
for p in positions:
pos = p.get("position", {})
pos_data.append({
"Actif": pos.get("coin"),
"Sens": "Long" if float(pos.get("szi", 0)) > 0 else "Short",
"Taille": abs(float(pos.get("szi", 0))),
"PnL latent": float(pos.get("unrealizedPnl", 0)),
"Prix d’entrée": float(pos.get("entryPx", 0)),
})
df = pd.DataFrame(pos_data)
st.dataframe(df)
fig = px.bar(
df,
x="Actif",
y="PnL latent",
color="Sens",
title="PnL latent par position"
)
st.plotly_chart(fig, use_container_width=True)
Cette version Streamlit donne une base simple : tu peux entrer une adresse, récupérer l’état du compte, afficher les positions et visualiser le PnL latent. À partir de là, tu peux ajouter l’historique des funding rates, des filtres par actif ou des alertes simples.
Construire un dashboard de production avec Grafana
Si tu as besoin de collaboration, d’historique long terme ou d’alertes plus propres, l’approche Grafana est préférable :
- Lance Grafana en local :
docker run -d -p 3000:3000 grafana/grafana - Configure une source de données PostgreSQL + TimescaleDB
- Écris un script Python planifié qui insère les données en base toutes les minutes
- Crée des panels Grafana avec des requêtes SQL
- Configure des règles d’alerte, par exemple lorsqu’un funding rate dépasse un seuil défini
La documentation officielle Grafana fournit un guide complet pour créer et configurer des panels.
OneKey Wallet : la base sécurité derrière ton dashboard
L’adresse de wallet saisie dans le dashboard sert à faire des requêtes en lecture seule. Mais dès que tu veux exécuter une transaction à partir d’un signal détecté, la sécurité de la clé privée devient essentielle.
Un hardware wallet OneKey stocke tes clés privées dans une puce de sécurité physique. Même si ton ordinateur est compromis par un malware, l’objectif est d’empêcher l’extraction directe de la clé privée depuis la machine.
Avec OneKey Perps, tu peux passer de l’analyse à l’exécution de manière plus sécurisée : ton dashboard t’aide à repérer une situation, puis tu utilises la signature matérielle pour interagir avec les contrats perpétuels Hyperliquid. L’idée est de créer une boucle simple : analyse des données, décision, exécution avec une meilleure hygiène de sécurité.
Tu peux télécharger OneKey et essayer OneKey Perps pour ajouter une couche de sécurité matérielle à ton workflow de trading, sans considérer cela comme une garantie de performance ou de profit.
FAQ
Q1 : Hyperliquid propose-t-il un plugin Grafana officiel ?
Non, il n’existe pas de plugin Grafana officiel dédié à Hyperliquid à ce stade. Tu peux toutefois utiliser une source de données JSON API ou le plugin Infinity de Grafana pour interroger l’API Hyperliquid, ou bien passer par une base intermédiaire comme PostgreSQL/TimescaleDB.
Q2 : Une connexion WebSocket peut-elle se déconnecter automatiquement ?
Oui. Une connexion WebSocket peut expirer après une longue période d’inactivité ou en cas de problème réseau. Il est recommandé d’ajouter une logique de heartbeat avec ping/pong et un mécanisme de reconnexion automatique pour garder la collecte de données stable.
Q3 : Le dashboard peut-il afficher les données d’un autre compte ?
Oui. Les données de compte Hyperliquid sont publiques et accessibles via les données on-chain ou les endpoints appropriés. Il suffit de fournir une adresse Ethereum valide. Cela signifie aussi que tes propres données peuvent être consultées par d’autres.
Q4 : Comment configurer une alerte sur un funding rate anormal ?
Tu peux ajouter une condition dans ton script de collecte : si le funding rate dépasse un seuil défini, par exemple 0,1 % par heure, le script envoie une alerte via Telegram Bot API ou par e-mail. Grafana dispose aussi de fonctionnalités d’alerte intégrées.
Q5 : Streamlit ou Grafana : lequel est le plus adapté aux débutants ?
Streamlit est plus simple pour un développeur Python qui veut obtenir un prototype rapidement, parfois en quelques dizaines de lignes. Grafana convient mieux à un environnement de production avec plusieurs utilisateurs, de l’historique, des dashboards partagés et des alertes avancées. Sa courbe d’apprentissage est un peu plus élevée, mais il est plus complet.
Risques à garder en tête
Cet article est un tutoriel technique et ne constitue pas un conseil en investissement, financier, juridique ou fiscal. Les marchés crypto sont volatils, et les données affichées dans un dashboard sont uniquement des informations d’aide à l’analyse. Elles ne prédisent pas les performances futures. Prends tes décisions de trading uniquement après avoir compris les risques et adapté ton exposition à ta situation.
