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 "services/wallet/WalletService.h"
#include "core/logging/Logger.h"
#include "datahub/DataHub.h"
#include "datahub/TopicPolicy.h"
#include "services/wallet/ConnectWalletDialog.h"
#include "services/wallet/PumpFunSwapService.h"
#include "services/wallet/SignTransactionDialog.h"
#include "services/wallet/SolanaRpcClient.h"
#include "services/wallet/TokenPriceProducer.h"
#include "services/wallet/WalletActivityProducer.h"
#include "services/wallet/WalletBalanceProducer.h"
#include "storage/secure/SecureStorage.h"
#include <QDateTime>
#include <QPointer>
#include <QWidget>
namespace fincept::wallet {
namespace {
// Persisted SecureStorage keys. See plan §4 for rationale.
constexpr const char* kKeyPubkey = "wallet.solana.pubkey";
constexpr const char* kKeyLabel = "wallet.solana.label";
constexpr const char* kKeyConnectedAt = "wallet.solana.connected_at";
} // namespace
WalletService& WalletService::instance() {
static WalletService s;
return s;
}
WalletService::WalletService() {
balance_producer_ = new WalletBalanceProducer(this);
price_producer_ = new TokenPriceProducer(this);
swap_service_ = new PumpFunSwapService(this);
activity_producer_ = new WalletActivityProducer(this);
}
WalletService::~WalletService() = default;
void WalletService::ensure_registered_with_hub() {
if (hub_registered_) {
return;
}
auto& hub = fincept::datahub::DataHub::instance();
hub.register_producer(balance_producer_);
hub.register_producer(price_producer_);
hub.register_producer(activity_producer_);
// PumpFunSwapService is one-shot (user-initiated build_swap call); it
// doesn't expose any hub topics and is not registered as a Producer.
// See CLAUDE.md D2 exception clause.
fincept::datahub::TopicPolicy balance_policy;
balance_policy.ttl_ms = 30 * 1000;
balance_policy.min_interval_ms = 10 * 1000;
balance_policy.refresh_timeout_ms = 15 * 1000;
hub.set_policy_pattern(QStringLiteral("wallet:balance:*"), balance_policy);
fincept::datahub::TopicPolicy price_policy;
price_policy.ttl_ms = 60 * 1000;
price_policy.min_interval_ms = 30 * 1000;
price_policy.refresh_timeout_ms = 15 * 1000;
price_policy.coalesce_within_ms = 250; // batch concurrent mint subscribes
// Phase 2 §2A.5: generalised topic family for any token's USD price.
hub.set_policy_pattern(QStringLiteral("market:price:token:*"), price_policy);
// Backward-compat alias kept for one phase. Removed in Phase 3.
hub.set_policy(QStringLiteral("market:price:fncpt"), price_policy);
// Phase 2 §2B: parsed activity feed.
fincept::datahub::TopicPolicy activity_policy;
activity_policy.ttl_ms = 30 * 1000;
activity_policy.min_interval_ms = 10 * 1000;
activity_policy.refresh_timeout_ms = 15 * 1000;
hub.set_policy_pattern(QStringLiteral("wallet:activity:*"), activity_policy);
hub_registered_ = true;
LOG_INFO("WalletService", "Registered with DataHub (wallet:balance:*, market:price:token:*, "
"market:price:fncpt[deprecated alias], wallet:activity:*)");
}
void WalletService::restore_from_storage() {
auto pk_res = SecureStorage::instance().retrieve(QString::fromLatin1(kKeyPubkey));
if (pk_res.is_err() || pk_res.value().isEmpty()) {
return;
}
WalletState s;
s.pubkey_b58 = pk_res.value();
auto lbl_res = SecureStorage::instance().retrieve(QString::fromLatin1(kKeyLabel));
if (lbl_res.is_ok()) {
s.label = lbl_res.value();
}
auto ts_res = SecureStorage::instance().retrieve(QString::fromLatin1(kKeyConnectedAt));
if (ts_res.is_ok()) {
bool ok = false;
const auto v = ts_res.value().toLongLong(&ok);
if (ok) {
s.connected_at_ms = v;
}
}
s.soft_connected = true;
set_state(std::move(s));
LOG_INFO("WalletService", "Restored soft-connected wallet: " + state_.pubkey_b58);
emit wallet_connected(state_.pubkey_b58, state_.label);
}
void WalletService::connect_with_dialog(QWidget* parent) {
auto* dlg = new ConnectWalletDialog(parent);
dlg->setAttribute(Qt::WA_DeleteOnClose);
QPointer<WalletService> self = this;
connect(dlg, &ConnectWalletDialog::connected, this, [self](QString pubkey, QString label) {
if (!self) {
return;
}
WalletState s;
s.pubkey_b58 = std::move(pubkey);
s.label = std::move(label);
s.connected_at_ms = QDateTime::currentMSecsSinceEpoch();
s.soft_connected = false;
self->set_state(std::move(s));
self->persist_state();
LOG_INFO("WalletService", "Wallet connected: " + self->state_.pubkey_b58);
emit self->wallet_connected(self->state_.pubkey_b58, self->state_.label);
});
connect(dlg, &ConnectWalletDialog::failed, this, [self](QString reason) {
if (!self) {
return;
}
LOG_WARN("WalletService", "Connect failed: " + reason);
emit self->connect_failed(reason);
});
dlg->open();
}
void WalletService::disconnect() {
if (!state_.is_connected()) {
return;
}
LOG_INFO("WalletService", "Disconnecting wallet: " + state_.pubkey_b58);
clear_persisted_state();
state_ = {};
emit wallet_disconnected();
}
void WalletService::set_state(WalletState s) {
state_ = std::move(s);
}
void WalletService::persist_state() {
auto& store = SecureStorage::instance();
store.store(QString::fromLatin1(kKeyPubkey), state_.pubkey_b58);
store.store(QString::fromLatin1(kKeyLabel), state_.label);
store.store(QString::fromLatin1(kKeyConnectedAt), QString::number(state_.connected_at_ms));
}
void WalletService::clear_persisted_state() {
auto& store = SecureStorage::instance();
store.remove(QString::fromLatin1(kKeyPubkey));
store.remove(QString::fromLatin1(kKeyLabel));
store.remove(QString::fromLatin1(kKeyConnectedAt));
}
void WalletService::set_balance_mode(bool stream) {
const auto wanted = stream ? BalanceMode::Stream : BalanceMode::Poll;
if (!balance_producer_) {
return;
}
if (balance_producer_->mode() == wanted) {
return;
}
SecureStorage::instance().store(QStringLiteral("wallet.balance_mode"),
stream ? QStringLiteral("stream") : QStringLiteral("poll"));
balance_producer_->set_mode(wanted);
LOG_INFO("WalletService", QStringLiteral("balance mode set to %1").arg(stream ? "stream" : "poll"));
// Force a refresh so subscribers see fresh data via the new path.
if (state_.is_connected()) {
const auto topic = QStringLiteral("wallet:balance:%1").arg(state_.pubkey_b58);
fincept::datahub::DataHub::instance().request(topic, /*force=*/true);
}
emit balance_mode_changed(stream);
}
bool WalletService::balance_mode_is_stream() const noexcept {
return balance_producer_ && balance_producer_->mode() == BalanceMode::Stream;
}
void WalletService::force_balance_refresh() {
if (!balance_producer_ || !state_.is_connected()) {
return;
}
balance_producer_->force_refresh(state_.pubkey_b58);
}
void WalletService::sign_and_send(const QString& tx_base64, const QString& dialog_title, const QString& dialog_lede,
QWidget* parent, std::function<void(Result<QString>)> cb) {
if (tx_base64.isEmpty()) {
if (cb)
cb(Result<QString>::err("empty_tx"));
return;
}
if (!state_.is_connected()) {
if (cb)
cb(Result<QString>::err("not_connected"));
return;
}
auto* dlg = new SignTransactionDialog(tx_base64, dialog_title, dialog_lede, parent);
dlg->setAttribute(Qt::WA_DeleteOnClose);
QPointer<SignTransactionDialog> guard = dlg;
connect(dlg, &QDialog::accepted, this, [this, guard, cb]() {
if (!cb || !guard)
return;
const QString result = guard->signature();
// resources/wallet/swap.html has two outcomes. A wallet that exposes
// signAndSendTransaction broadcasts the tx itself and the page posts the
// base58 signature. A wallet that only exposes signTransaction cannot
// broadcast, so the page posts "BYTES:<base64 signed tx>" and leaves the
// forwarding to us ("caller forwards via RPC" in the page source). Nothing
// in the C++ side handled that prefix, so the raw "BYTES:…" string was
// handed back as if it were a signature: callers polled
// getSignatureStatuses with it for a minute and reported a timeout while
// the signed transaction was never sent.
static const QString kSignedBytesPrefix = QStringLiteral("BYTES:");
if (!result.startsWith(kSignedBytesPrefix)) {
cb(Result<QString>::ok(result));
return;
}
const QString signed_b64 = result.mid(kSignedBytesPrefix.size());
if (signed_b64.isEmpty()) {
cb(Result<QString>::err("empty_signed_tx"));
return;
}
LOG_INFO("WalletService", "wallet returned a signed transaction without sending — broadcasting via RPC");
auto* rpc = new SolanaRpcClient(this);
rpc->reload_endpoint();
rpc->send_transaction(signed_b64, [rpc, cb](Result<QString> sent) {
rpc->deleteLater();
cb(std::move(sent));
});
});
connect(dlg, &QDialog::rejected, this, [guard, cb]() {
if (!cb || !guard)
return;
const auto reason = guard->failure_reason();
cb(Result<QString>::err(reason.isEmpty() ? std::string("rejected") : reason.toStdString()));
});
dlg->open();
}
} // namespace fincept::wallet