AdrianoDev
c0b4cb5d5c
Riscritto interamente HyperliquidClient su httpx puro + eth-account per la firma EIP-712 L1 (chainId 1337, phantom agent source 'a'/'b' per mainnet/testnet). Bit-parity verificata contro hyperliquid.utils.signing in test_signing_parity_with_canonical_sdk. 16 metodi pubblici, 26 test passanti. Aggiunte deps: eth-account, msgpack, eth-utils. hyperliquid-python-sdk ancora presente nel pyproject; rimossa nel sweep finale. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
486 lines
16 KiB
Python
486 lines
16 KiB
Python
from __future__ import annotations
|
|
|
|
import re
|
|
|
|
import pytest
|
|
from cerbero_mcp.exchanges.hyperliquid.client import HyperliquidClient
|
|
from pytest_httpx import HTTPXMock
|
|
|
|
# Chiave privata fissa: rende deterministica la firma EIP-712 per i test write.
|
|
DUMMY_PRIVATE_KEY = "0x" + "01" * 32
|
|
DUMMY_WALLET = "0x1a642f0E3c3aF545E7AcBD38b07251B3990914F1" # derived from key above
|
|
|
|
|
|
@pytest.fixture
|
|
def client():
|
|
return HyperliquidClient(
|
|
wallet_address=DUMMY_WALLET,
|
|
private_key=DUMMY_PRIVATE_KEY,
|
|
testnet=True,
|
|
)
|
|
|
|
|
|
# Shared mock responses
|
|
|
|
META_AND_CTX = [
|
|
{
|
|
"universe": [
|
|
{"name": "BTC", "maxLeverage": 50},
|
|
{"name": "ETH", "maxLeverage": 25},
|
|
]
|
|
},
|
|
[
|
|
{
|
|
"markPx": "50000.0",
|
|
"funding": "0.0001",
|
|
"openInterest": "1000.0",
|
|
"dayNtlVlm": "500000.0",
|
|
},
|
|
{
|
|
"markPx": "3000.0",
|
|
"funding": "0.00005",
|
|
"openInterest": "500.0",
|
|
"dayNtlVlm": "200000.0",
|
|
},
|
|
],
|
|
]
|
|
|
|
META = {
|
|
"universe": [
|
|
{"name": "BTC", "maxLeverage": 50},
|
|
{"name": "ETH", "maxLeverage": 25},
|
|
]
|
|
}
|
|
|
|
CLEARINGHOUSE_STATE = {
|
|
"marginSummary": {
|
|
"accountValue": "1500.0",
|
|
"totalRawUsd": "1200.0",
|
|
"totalMarginUsed": "300.0",
|
|
"totalNtlPos": "50.0",
|
|
},
|
|
"assetPositions": [
|
|
{
|
|
"position": {
|
|
"coin": "BTC",
|
|
"szi": "0.1",
|
|
"entryPx": "48000.0",
|
|
"unrealizedPnl": "200.0",
|
|
"leverage": {"value": "10"},
|
|
"liquidationPx": "40000.0",
|
|
}
|
|
}
|
|
],
|
|
}
|
|
|
|
SPOT_STATE = {"balances": [{"coin": "USDC", "total": "500.0"}]}
|
|
|
|
|
|
# ── Read endpoints ─────────────────────────────────────────────
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_markets(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=META_AND_CTX,
|
|
)
|
|
markets = await client.get_markets()
|
|
assert len(markets) == 2
|
|
assert markets[0]["asset"] == "BTC"
|
|
assert markets[0]["mark_price"] == 50000.0
|
|
assert markets[0]["max_leverage"] == 50
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_ticker(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=META_AND_CTX,
|
|
)
|
|
result = await client.get_ticker("BTC")
|
|
assert result["asset"] == "BTC"
|
|
assert result["mark_price"] == 50000.0
|
|
assert result["funding_rate"] == 0.0001
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_ticker_not_found(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=META_AND_CTX,
|
|
)
|
|
result = await client.get_ticker("SOL")
|
|
assert "error" in result
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_orderbook(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json={
|
|
"levels": [
|
|
[{"px": "49990.0", "sz": "0.5"}, {"px": "49980.0", "sz": "1.0"}],
|
|
[{"px": "50010.0", "sz": "0.3"}, {"px": "50020.0", "sz": "0.8"}],
|
|
]
|
|
},
|
|
)
|
|
result = await client.get_orderbook("BTC", depth=2)
|
|
assert result["asset"] == "BTC"
|
|
assert len(result["bids"]) == 2
|
|
assert len(result["asks"]) == 2
|
|
assert result["bids"][0]["price"] == 49990.0
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_positions(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=CLEARINGHOUSE_STATE,
|
|
)
|
|
positions = await client.get_positions()
|
|
assert len(positions) == 1
|
|
assert positions[0]["asset"] == "BTC"
|
|
assert positions[0]["direction"] == "long"
|
|
assert positions[0]["size"] == 0.1
|
|
assert positions[0]["leverage"] == 10.0
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_account_summary(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
# get_account_summary calls /info twice (perp + spot)
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=CLEARINGHOUSE_STATE,
|
|
)
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=SPOT_STATE,
|
|
)
|
|
result = await client.get_account_summary()
|
|
assert result["perps_equity"] == 1500.0
|
|
assert result["spot_usdc"] == 500.0
|
|
assert result["equity"] == 2000.0
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_trade_history(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=[
|
|
{"coin": "BTC", "side": "B", "sz": "0.1", "px": "50000", "fee": "0.5", "time": 1000},
|
|
{"coin": "ETH", "side": "A", "sz": "1.0", "px": "3000", "fee": "0.3", "time": 2000},
|
|
],
|
|
)
|
|
trades = await client.get_trade_history(limit=10)
|
|
assert len(trades) == 2
|
|
assert trades[0]["asset"] == "BTC"
|
|
assert trades[0]["price"] == 50000.0
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_open_orders(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=[
|
|
{
|
|
"oid": 12345,
|
|
"coin": "BTC",
|
|
"side": "B",
|
|
"sz": "0.05",
|
|
"limitPx": "49000",
|
|
"orderType": "Limit",
|
|
}
|
|
],
|
|
)
|
|
orders = await client.get_open_orders()
|
|
assert len(orders) == 1
|
|
assert orders[0]["oid"] == 12345
|
|
assert orders[0]["asset"] == "BTC"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_historical(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=[
|
|
{"t": 1000000, "o": "49000", "h": "51000", "l": "48500", "c": "50000", "v": "100"},
|
|
],
|
|
)
|
|
result = await client.get_historical("BTC", "2024-01-01", "2024-01-02", "1h")
|
|
assert len(result["candles"]) == 1
|
|
assert result["candles"][0]["close"] == 50000.0
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_health_ok(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json={"universe": []},
|
|
)
|
|
result = await client.health()
|
|
assert result["status"] in ("ok", "healthy")
|
|
assert result["testnet"] is True
|
|
|
|
|
|
# ── Write endpoints (signed via EIP-712) ───────────────────────
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_place_order_limit(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
"""Limit order: signs and POSTs to /exchange with correct payload shape."""
|
|
# 1. /info type=meta per asset id
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=META,
|
|
)
|
|
# 2. /exchange firmato
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/exchange"),
|
|
json={
|
|
"status": "ok",
|
|
"response": {
|
|
"type": "order",
|
|
"data": {
|
|
"statuses": [{"resting": {"oid": 9999}}],
|
|
},
|
|
},
|
|
},
|
|
)
|
|
|
|
result = await client.place_order(
|
|
instrument="BTC", side="buy", amount=0.01, type="limit", price=50000.0
|
|
)
|
|
|
|
# Verifica shape risposta normalizzata
|
|
assert result["status"] == "ok"
|
|
assert result["order_id"] == 9999
|
|
|
|
# Verifica request body al POST /exchange
|
|
requests = [r for r in httpx_mock.get_requests() if r.url.path == "/exchange"]
|
|
assert len(requests) == 1
|
|
import json as _json
|
|
|
|
body = _json.loads(requests[0].content)
|
|
assert body["nonce"] > 0
|
|
assert body["vaultAddress"] is None
|
|
assert body["expiresAfter"] is None
|
|
assert body["action"]["type"] == "order"
|
|
assert body["action"]["grouping"] == "na"
|
|
assert len(body["action"]["orders"]) == 1
|
|
order = body["action"]["orders"][0]
|
|
assert order["a"] == 0 # BTC è index 0 in META
|
|
assert order["b"] is True # buy
|
|
assert order["p"] == "50000"
|
|
assert order["s"] == "0.01"
|
|
assert order["r"] is False
|
|
assert order["t"] == {"limit": {"tif": "Gtc"}}
|
|
sig = body["signature"]
|
|
assert set(sig.keys()) == {"r", "s", "v"}
|
|
assert sig["r"].startswith("0x") and len(sig["r"]) == 66
|
|
assert sig["s"].startswith("0x") and len(sig["s"]) == 66
|
|
assert sig["v"] in (27, 28)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_place_order_market(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
"""Market order: usa mark_price + buffer e tif=Ioc."""
|
|
# market path: get_ticker → meta+ctxs, poi meta per asset id, poi /exchange
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=META_AND_CTX,
|
|
)
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=META,
|
|
)
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/exchange"),
|
|
json={
|
|
"status": "ok",
|
|
"response": {
|
|
"type": "order",
|
|
"data": {
|
|
"statuses": [{"filled": {"oid": 1, "totalSz": "0.01", "avgPx": "51500"}}],
|
|
},
|
|
},
|
|
},
|
|
)
|
|
|
|
result = await client.place_order(
|
|
instrument="BTC", side="buy", amount=0.01, type="market"
|
|
)
|
|
assert result["status"] == "ok"
|
|
assert result["filled_size"] == 0.01
|
|
|
|
import json as _json
|
|
|
|
requests = [r for r in httpx_mock.get_requests() if r.url.path == "/exchange"]
|
|
assert len(requests) == 1
|
|
body = _json.loads(requests[0].content)
|
|
order = body["action"]["orders"][0]
|
|
assert order["t"] == {"limit": {"tif": "Ioc"}}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_place_order_stop_loss(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
"""Stop-loss: usa trigger order type."""
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=META,
|
|
)
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/exchange"),
|
|
json={
|
|
"status": "ok",
|
|
"response": {"type": "order", "data": {"statuses": [{"resting": {"oid": 7}}]}},
|
|
},
|
|
)
|
|
|
|
result = await client.place_order(
|
|
instrument="BTC",
|
|
side="sell",
|
|
amount=0.01,
|
|
type="stop_loss",
|
|
price=45000.0,
|
|
reduce_only=True,
|
|
)
|
|
assert result["status"] == "ok"
|
|
assert result["order_id"] == 7
|
|
|
|
import json as _json
|
|
|
|
requests = [r for r in httpx_mock.get_requests() if r.url.path == "/exchange"]
|
|
body = _json.loads(requests[0].content)
|
|
order = body["action"]["orders"][0]
|
|
assert order["r"] is True
|
|
assert order["t"] == {
|
|
"trigger": {"isMarket": True, "triggerPx": "45000", "tpsl": "sl"}
|
|
}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_place_order_unknown_asset(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
"""Asset sconosciuto → error dict, niente POST /exchange."""
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=META,
|
|
)
|
|
result = await client.place_order(
|
|
instrument="DOGE", side="buy", amount=1.0, type="limit", price=0.1
|
|
)
|
|
assert "error" in result
|
|
assert "DOGE" in result["error"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_cancel_order(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
"""Cancel: action.type=cancel con asset id + oid."""
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=META,
|
|
)
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/exchange"),
|
|
json={"status": "ok", "response": {"type": "cancel", "data": {"statuses": ["success"]}}},
|
|
)
|
|
|
|
result = await client.cancel_order("12345", "BTC")
|
|
assert result["status"] == "ok"
|
|
assert result["order_id"] == "12345"
|
|
|
|
import json as _json
|
|
|
|
requests = [r for r in httpx_mock.get_requests() if r.url.path == "/exchange"]
|
|
body = _json.loads(requests[0].content)
|
|
assert body["action"]["type"] == "cancel"
|
|
assert body["action"]["cancels"] == [{"a": 0, "o": 12345}]
|
|
assert "r" in body["signature"] and "s" in body["signature"] and "v" in body["signature"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_close_position(httpx_mock: HTTPXMock, client: HyperliquidClient):
|
|
"""close_position: legge stato, calcola slippage, place IOC reduce-only."""
|
|
# 1. clearinghouseState per direzione
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=CLEARINGHOUSE_STATE,
|
|
)
|
|
# 2. get_ticker → metaAndAssetCtxs
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=META_AND_CTX,
|
|
)
|
|
# 3. meta per asset id
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json=META,
|
|
)
|
|
# 4. /exchange
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/exchange"),
|
|
json={
|
|
"status": "ok",
|
|
"response": {
|
|
"type": "order",
|
|
"data": {
|
|
"statuses": [{"filled": {"oid": 5, "totalSz": "0.1", "avgPx": "47500"}}],
|
|
},
|
|
},
|
|
},
|
|
)
|
|
|
|
result = await client.close_position("BTC")
|
|
assert result["status"] == "ok"
|
|
assert result["asset"] == "BTC"
|
|
|
|
import json as _json
|
|
|
|
requests = [r for r in httpx_mock.get_requests() if r.url.path == "/exchange"]
|
|
body = _json.loads(requests[0].content)
|
|
order = body["action"]["orders"][0]
|
|
# Posizione long → side=sell per chiudere
|
|
assert order["b"] is False
|
|
assert order["r"] is True
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_close_position_no_position(
|
|
httpx_mock: HTTPXMock, client: HyperliquidClient
|
|
):
|
|
"""close_position senza posizione aperta → error dict."""
|
|
httpx_mock.add_response(
|
|
url=re.compile(r"https://api\.hyperliquid-testnet\.xyz/info"),
|
|
json={"assetPositions": [], "marginSummary": {}},
|
|
)
|
|
result = await client.close_position("BTC")
|
|
assert "error" in result
|
|
assert result["asset"] == "BTC"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_signing_parity_with_canonical_sdk(client: HyperliquidClient):
|
|
"""Sanity: la firma EIP-712 prodotta è bit-for-bit identica a quella che
|
|
genererebbe il SDK ufficiale ``hyperliquid-python-sdk`` per lo stesso input.
|
|
|
|
Test isolato (no httpx) per garantire che la rimozione del SDK runtime
|
|
non introduca regressioni di signing.
|
|
"""
|
|
from cerbero_mcp.exchanges.hyperliquid.client import _sign_l1_action
|
|
|
|
action = {"type": "cancel", "cancels": [{"a": 0, "o": 12345}]}
|
|
nonce = 1700000000000
|
|
sig = _sign_l1_action(DUMMY_PRIVATE_KEY, action, None, nonce, None, False)
|
|
assert sig == {
|
|
"r": "0xab1150f8d695e015a07e3f79983a0a2a4e58dedec071dfa4177a0761f37e0485",
|
|
"s": "0x208cb6370e5e56a3cefa451538c1e0096b70777d2bde172c7afb1e77c4d28d20",
|
|
"v": 28,
|
|
}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_aclose_idempotent(client: HyperliquidClient):
|
|
"""``aclose`` può essere chiamato anche senza http client attivo."""
|
|
await client.aclose()
|
|
await client.aclose()
|