FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
#include "trading/exchanges/hyperliquid/HyperliquidClient.h"
#include "core/logging/Logger.h"
#include <QJsonDocument>
#include <QJsonObject>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QPointer>
#include <QWebSocket>
namespace fincept::trading::hyperliquid {
namespace {
const QString kMainnetRest = QStringLiteral("https://api.hyperliquid.xyz");
const QString kMainnetWs = QStringLiteral("wss://api.hyperliquid.xyz/ws");
const QString kTestnetRest = QStringLiteral("https://api.hyperliquid-testnet.xyz");
const QString kTestnetWs = QStringLiteral("wss://api.hyperliquid-testnet.xyz/ws");
} // namespace
class HyperliquidClient::WsHolder : public QObject {
public:
explicit WsHolder(HyperliquidClient* parent) : QObject(parent), owner_(parent) {
connect(&socket_, &QWebSocket::connected, this, [this]() {
owner_->emit ws_state_changed(static_cast<int>(QAbstractSocket::ConnectedState));
for (const auto& s : pending_subs_)
socket_.sendTextMessage(s);
pending_subs_.clear();
});
connect(&socket_, &QWebSocket::disconnected, this,
[this]() { owner_->emit ws_state_changed(static_cast<int>(QAbstractSocket::UnconnectedState)); });
connect(&socket_, &QWebSocket::textMessageReceived, this, [this](const QString& s) {
auto doc = QJsonDocument::fromJson(s.toUtf8());
if (doc.isObject())
emit owner_->ws_message(doc.object());
});
}
void open(const QString& url) { socket_.open(QUrl(url)); }
void close() { socket_.close(); }
bool is_open() const { return socket_.state() == QAbstractSocket::ConnectedState; }
void send_or_queue(const QString& text) {
if (is_open())
socket_.sendTextMessage(text);
else
pending_subs_.append(text);
}
private:
HyperliquidClient* owner_;
QWebSocket socket_;
QStringList pending_subs_;
};
HyperliquidClient::HyperliquidClient(QObject* parent) : QObject(parent) {}
HyperliquidClient::~HyperliquidClient() {
disconnect_ws();
}
void HyperliquidClient::set_testnet(bool testnet) {
testnet_ = testnet;
}
QString HyperliquidClient::rest_base() const {
return testnet_ ? kTestnetRest : kMainnetRest;
}
QString HyperliquidClient::ws_base() const {
return testnet_ ? kTestnetWs : kMainnetWs;
}
void HyperliquidClient::post_json(const QString& url, const QJsonObject& body, JsonCallback cb) {
static QNetworkAccessManager s_nam;
QNetworkRequest req(QUrl{url});
req.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
// 30s transfer timeout so a stalled connection errors instead of hanging a
// round forever. Safe for the live venue too: HL REST normally replies in
// well under a second, and a timed-out order surfaces as a venue error.
req.setTransferTimeout(30000);
QPointer<HyperliquidClient> self(this);
auto* reply = s_nam.post(req, QJsonDocument(body).toJson(QJsonDocument::Compact));
connect(reply, &QNetworkReply::finished, this, [reply, cb]() {
const auto data = reply->readAll();
const auto err = reply->error();
reply->deleteLater();
if (err != QNetworkReply::NoError) {
cb(Result<QJsonDocument>::err(reply->errorString().toStdString()));
return;
}
QJsonParseError pe;
const auto doc = QJsonDocument::fromJson(data, &pe);
if (pe.error != QJsonParseError::NoError) {
cb(Result<QJsonDocument>::err(pe.errorString().toStdString()));
return;
}
cb(Result<QJsonDocument>::ok(doc));
});
}
void HyperliquidClient::info(const QJsonObject& body, JsonCallback cb) {
post_json(rest_base() + QStringLiteral("/info"), body, std::move(cb));
}
void HyperliquidClient::exchange(const QJsonObject& signed_envelope, JsonCallback cb) {
post_json(rest_base() + QStringLiteral("/exchange"), signed_envelope, std::move(cb));
}
void HyperliquidClient::connect_ws() {
if (!ws_)
ws_ = new WsHolder(this);
ws_->open(ws_base());
}
void HyperliquidClient::disconnect_ws() {
if (ws_)
ws_->close();
}
bool HyperliquidClient::ws_connected() const {
return ws_ && ws_->is_open();
}
void HyperliquidClient::subscribe(const QJsonObject& subscription) {
if (!ws_)
connect_ws();
QJsonObject env;
env[QStringLiteral("method")] = QStringLiteral("subscribe");
env[QStringLiteral("subscription")] = subscription;
ws_->send_or_queue(QString::fromUtf8(QJsonDocument(env).toJson(QJsonDocument::Compact)));
}
void HyperliquidClient::unsubscribe(const QJsonObject& subscription) {
if (!ws_)
return;
QJsonObject env;
env[QStringLiteral("method")] = QStringLiteral("unsubscribe");
env[QStringLiteral("subscription")] = subscription;
ws_->send_or_queue(QString::fromUtf8(QJsonDocument(env).toJson(QJsonDocument::Compact)));
}
} // namespace fincept::trading::hyperliquid