perf(net): one balance scan per poll, filtered opstatus, a guarded merge scope
The Core poll ran z_gettotalbalance twice (minconf 0 and 1), each a whole- wallet scan under dragonxd's cs_main. The spendable (minconf=1) call now runs only after the display call succeeded, and only when something is unconfirmed or pending or the exact total moved: about 95% of polls make one scan instead of two. A forced post-send balance can no longer be lost to a refused enqueue, and pending-send debits aren't re-applied each tick. z_getoperationstatus is filtered to our opids with its real argument form ([[id,...]]; the old ["id"] was rejected), falling back to the unfiltered call if a daemon refuses the filter. The Shield/Merge dialog's own polls are filtered and session-guarded too, and finally reach Done; the dead RPCClient wrappers are deleted. The Merge/Consolidate scope scan becomes a tested state machine: one scan at a time, failures latch behind a Retry button, only "node not ready" retries by itself (10/30/60 s, at most 3), Lite never scans. Its 120 s calls are maintenance calls: every main-thread disconnect aborts one in flight first, so a lifecycle action no longer freezes the UI behind it. An aborted merge that was already sent says it may still go through. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5.5
@@ -1178,10 +1178,12 @@
|
||||
"merge_keep_each_status_failed": "%s – fehlgeschlagen: %s",
|
||||
"merge_keep_each_status_not_started": "%s – nicht gestartet: %s",
|
||||
"merge_keep_each_status_running": "%s – %d Notes werden zusammengeführt (%d von %d Durchgängen fertig)…",
|
||||
"merge_keep_each_status_unconfirmed": "%s – Status konnte nicht bestätigt werden",
|
||||
"merge_keep_each_too_small": "Zu klein zum Konsolidieren: Die Gebühr würde diese Mittel aufbrauchen.",
|
||||
"merge_max_inputs": "Max. Inputs pro Batch",
|
||||
"merge_no_spendable": "Noch keine verfügbaren Inputs zum Konsolidieren.",
|
||||
"merge_progress": "Konsolidierung läuft… dies kann einige Minuten dauern. Sie können dieses Fenster schließen.",
|
||||
"merge_scope_failed_fmt": "Ihre Inputs konnten nicht gelesen werden: %s",
|
||||
"merge_scope_fmt": "%d transparente + %d geschützte Inputs · ~%s DRGX verfügbar",
|
||||
"merge_scope_loading": "Ihre Inputs werden geprüft…",
|
||||
"merge_send_failed": "Zusammenführen fehlgeschlagen: ",
|
||||
@@ -1190,7 +1192,10 @@
|
||||
"merge_src_shielded": "Geschützt",
|
||||
"merge_src_transparent": "Transparent",
|
||||
"merge_started": "Zusammenführung gestartet",
|
||||
"merge_submit_uncertain": "Der Node hat das Zusammenführen nicht bestätigt, bevor die Verbindung unterbrochen wurde. Es kann trotzdem ausgeführt werden – prüfen Sie nach dem erneuten Verbinden den Verlauf, bevor Sie erneut zusammenführen.",
|
||||
"merge_title": "An Adresse zusammenführen",
|
||||
"merge_wait_locked": "Die Wallet ist gesperrt. Entsperren Sie sie, um fortzufahren.",
|
||||
"merge_waiting_node": "Warten auf den Node…",
|
||||
"merge_where": "Wohin sollen die Mittel gehen?",
|
||||
"mig_adopt": "Dies zu meiner Wallet machen",
|
||||
"mig_adopt_now": "Seed-Wallet übernehmen",
|
||||
|
||||
@@ -1178,10 +1178,12 @@
|
||||
"merge_keep_each_status_failed": "%s: falló: %s",
|
||||
"merge_keep_each_status_not_started": "%s: no iniciado: %s",
|
||||
"merge_keep_each_status_running": "%s: fusionando %d notas (%d de %d lotes listos)…",
|
||||
"merge_keep_each_status_unconfirmed": "%s: no se pudo confirmar el estado",
|
||||
"merge_keep_each_too_small": "Demasiado poco para consolidar: la comisión se llevaría estos fondos.",
|
||||
"merge_max_inputs": "Máximo de entradas por lote",
|
||||
"merge_no_spendable": "Aún no hay entradas disponibles para consolidar.",
|
||||
"merge_progress": "Consolidando… esto puede tardar varios minutos. Puedes cerrar esta ventana.",
|
||||
"merge_scope_failed_fmt": "No se pudieron leer tus entradas: %s",
|
||||
"merge_scope_fmt": "%d entradas transparentes + %d blindadas · ~%s DRGX disponibles",
|
||||
"merge_scope_loading": "Comprobando tus entradas…",
|
||||
"merge_send_failed": "Error al fusionar: ",
|
||||
@@ -1190,7 +1192,10 @@
|
||||
"merge_src_shielded": "Blindadas",
|
||||
"merge_src_transparent": "Transparentes",
|
||||
"merge_started": "Operación de fusión iniciada",
|
||||
"merge_submit_uncertain": "El nodo no confirmó la fusión antes de que se interrumpiera la conexión. Puede que aún se complete: revisa el Historial tras reconectar antes de fusionar de nuevo.",
|
||||
"merge_title": "Fusionar a Dirección",
|
||||
"merge_wait_locked": "La cartera está bloqueada. Desbloquéala para continuar.",
|
||||
"merge_waiting_node": "Esperando al nodo…",
|
||||
"merge_where": "¿Adónde deben ir los fondos?",
|
||||
"mig_adopt": "Hacer que esta sea mi cartera",
|
||||
"mig_adopt_now": "Adoptar cartera con frase",
|
||||
|
||||
@@ -1178,10 +1178,12 @@
|
||||
"merge_keep_each_status_failed": "%s — échec : %s",
|
||||
"merge_keep_each_status_not_started": "%s — non démarré : %s",
|
||||
"merge_keep_each_status_running": "%s — fusion de %d notes (%d lots sur %d terminés)…",
|
||||
"merge_keep_each_status_unconfirmed": "%s — statut non confirmé",
|
||||
"merge_keep_each_too_small": "Trop faible pour être consolidé : les frais absorberaient ces fonds.",
|
||||
"merge_max_inputs": "Nombre max d'entrées par lot",
|
||||
"merge_no_spendable": "Aucune entrée dépensable à consolider pour l'instant.",
|
||||
"merge_progress": "Consolidation en cours… cela peut prendre quelques minutes. Vous pouvez fermer cette fenêtre.",
|
||||
"merge_scope_failed_fmt": "Impossible de lire vos entrées : %s",
|
||||
"merge_scope_fmt": "%d entrées transparentes + %d blindées · ~%s DRGX dépensables",
|
||||
"merge_scope_loading": "Vérification de vos entrées…",
|
||||
"merge_send_failed": "Échec de la fusion : ",
|
||||
@@ -1190,7 +1192,10 @@
|
||||
"merge_src_shielded": "Blindées",
|
||||
"merge_src_transparent": "Transparentes",
|
||||
"merge_started": "Opération de fusion démarrée",
|
||||
"merge_submit_uncertain": "Le nœud n'a pas confirmé la fusion avant l'interruption de la connexion. Elle peut tout de même aboutir — vérifiez l'Historique après la reconnexion avant de fusionner à nouveau.",
|
||||
"merge_title": "Fusionner vers une adresse",
|
||||
"merge_wait_locked": "Le portefeuille est verrouillé. Déverrouillez-le pour continuer.",
|
||||
"merge_waiting_node": "En attente du nœud…",
|
||||
"merge_where": "Où doivent aller les fonds ?",
|
||||
"mig_adopt": "Faire de ceci mon portefeuille",
|
||||
"mig_adopt_now": "Adopter le portefeuille à phrase",
|
||||
|
||||
@@ -1178,10 +1178,12 @@
|
||||
"merge_keep_each_status_failed": "%s — 失敗：%s",
|
||||
"merge_keep_each_status_not_started": "%s — 開始されませんでした：%s",
|
||||
"merge_keep_each_status_running": "%s — %d 件のノートを統合中（%d / %d 回完了）…",
|
||||
"merge_keep_each_status_unconfirmed": "%s — ステータスを確認できませんでした",
|
||||
"merge_keep_each_too_small": "少なすぎて統合できません。手数料でこの資金がなくなります。",
|
||||
"merge_max_inputs": "バッチあたりの最大入力数",
|
||||
"merge_no_spendable": "統合できる使用可能な入力がまだありません。",
|
||||
"merge_progress": "統合中… 数分かかることがあります。このウィンドウは閉じても構いません。",
|
||||
"merge_scope_failed_fmt": "入力を読み取れませんでした: %s",
|
||||
"merge_scope_fmt": "透明%d件 + シールド%d件の入力 · 使用可能 約%s DRGX",
|
||||
"merge_scope_loading": "入力を確認中…",
|
||||
"merge_send_failed": "マージに失敗しました: ",
|
||||
@@ -1190,7 +1192,10 @@
|
||||
"merge_src_shielded": "シールド",
|
||||
"merge_src_transparent": "透明",
|
||||
"merge_started": "統合操作を開始しました",
|
||||
"merge_submit_uncertain": "接続が中断される前に、ノードはマージを確認しませんでした。マージは実行される可能性があります — 再接続後、もう一度マージする前に「履歴」を確認してください。",
|
||||
"merge_title": "アドレスに統合",
|
||||
"merge_wait_locked": "ウォレットがロックされています。続行するにはロックを解除してください。",
|
||||
"merge_waiting_node": "ノードを待っています…",
|
||||
"merge_where": "資金の移動先",
|
||||
"mig_adopt": "これを自分のウォレットにする",
|
||||
"mig_adopt_now": "シードウォレットを採用",
|
||||
|
||||
@@ -1178,10 +1178,12 @@
|
||||
"merge_keep_each_status_failed": "%s — 실패: %s",
|
||||
"merge_keep_each_status_not_started": "%s — 시작되지 않음: %s",
|
||||
"merge_keep_each_status_running": "%s — 노트 %d개 병합 중(%d/%d 배치 완료)…",
|
||||
"merge_keep_each_status_unconfirmed": "%s — 상태를 확인할 수 없음",
|
||||
"merge_keep_each_too_small": "너무 적어서 통합할 수 없습니다. 수수료가 이 자금을 모두 소모합니다.",
|
||||
"merge_max_inputs": "배치당 최대 입력 수",
|
||||
"merge_no_spendable": "아직 통합할 사용 가능한 입력이 없습니다.",
|
||||
"merge_progress": "통합 중… 몇 분 정도 걸릴 수 있습니다. 이 창을 닫아도 됩니다.",
|
||||
"merge_scope_failed_fmt": "입력을 읽을 수 없습니다: %s",
|
||||
"merge_scope_fmt": "투명 입력 %d개 + 보호 입력 %d개 · 사용 가능 약 %s DRGX",
|
||||
"merge_scope_loading": "입력을 확인하는 중…",
|
||||
"merge_send_failed": "통합 실패: ",
|
||||
@@ -1190,7 +1192,10 @@
|
||||
"merge_src_shielded": "보호",
|
||||
"merge_src_transparent": "투명",
|
||||
"merge_started": "통합 작업이 시작되었습니다",
|
||||
"merge_submit_uncertain": "연결이 끊기기 전에 노드가 통합을 확인하지 않았습니다. 그래도 처리될 수 있습니다 — 다시 연결한 후 다시 통합하기 전에 내역을 확인하세요.",
|
||||
"merge_title": "주소로 통합",
|
||||
"merge_wait_locked": "지갑이 잠겨 있습니다. 계속하려면 잠금을 해제하세요.",
|
||||
"merge_waiting_node": "노드를 기다리는 중…",
|
||||
"merge_where": "자금을 어디로 보낼까요?",
|
||||
"mig_adopt": "이 지갑을 내 지갑으로 사용",
|
||||
"mig_adopt_now": "시드 지갑 사용",
|
||||
|
||||
@@ -1178,10 +1178,12 @@
|
||||
"merge_keep_each_status_failed": "%s — falhou: %s",
|
||||
"merge_keep_each_status_not_started": "%s — não iniciado: %s",
|
||||
"merge_keep_each_status_running": "%s — mesclando %d notas (%d de %d lotes concluídos)…",
|
||||
"merge_keep_each_status_unconfirmed": "%s — não foi possível confirmar o status",
|
||||
"merge_keep_each_too_small": "Pequeno demais para consolidar: a taxa consumiria esses fundos.",
|
||||
"merge_max_inputs": "Máx. de entradas por lote",
|
||||
"merge_no_spendable": "Ainda não há entradas disponíveis para consolidar.",
|
||||
"merge_progress": "Consolidando… isso pode levar alguns minutos. Você pode fechar esta janela.",
|
||||
"merge_scope_failed_fmt": "Não foi possível ler suas entradas: %s",
|
||||
"merge_scope_fmt": "%d entradas transparentes + %d blindadas · ~%s DRGX disponíveis",
|
||||
"merge_scope_loading": "Verificando suas entradas…",
|
||||
"merge_send_failed": "Falha na fusão: ",
|
||||
@@ -1190,7 +1192,10 @@
|
||||
"merge_src_shielded": "Blindado",
|
||||
"merge_src_transparent": "Transparente",
|
||||
"merge_started": "Operação de fusão iniciada",
|
||||
"merge_submit_uncertain": "O nó não confirmou a fusão antes de a conexão ser interrompida. Ela ainda pode ser concluída — verifique o Histórico após reconectar antes de fundir novamente.",
|
||||
"merge_title": "Fundir para Endereço",
|
||||
"merge_wait_locked": "A carteira está bloqueada. Desbloqueie-a para continuar.",
|
||||
"merge_waiting_node": "Aguardando o nó…",
|
||||
"merge_where": "Para onde devem ir os fundos?",
|
||||
"mig_adopt": "Tornar esta minha carteira",
|
||||
"mig_adopt_now": "Adotar carteira semente",
|
||||
|
||||
@@ -1178,10 +1178,12 @@
|
||||
"merge_keep_each_status_failed": "%s — ошибка: %s",
|
||||
"merge_keep_each_status_not_started": "%s — не запущено: %s",
|
||||
"merge_keep_each_status_running": "%s — объединение %d заметок (готово партий: %d из %d)…",
|
||||
"merge_keep_each_status_unconfirmed": "%s — статус не удалось подтвердить",
|
||||
"merge_keep_each_too_small": "Слишком мало для объединения: комиссия съест эти средства.",
|
||||
"merge_max_inputs": "Макс. входов за партию",
|
||||
"merge_no_spendable": "Пока нет доступных для расходования входов для объединения.",
|
||||
"merge_progress": "Объединение… это может занять несколько минут. Вы можете закрыть это окно.",
|
||||
"merge_scope_failed_fmt": "Не удалось прочитать ваши входы: %s",
|
||||
"merge_scope_fmt": "%d прозрачных + %d защищённых входов · ~%s DRGX доступно",
|
||||
"merge_scope_loading": "Проверка ваших входов…",
|
||||
"merge_send_failed": "Ошибка объединения: ",
|
||||
@@ -1190,7 +1192,10 @@
|
||||
"merge_src_shielded": "Защищённые",
|
||||
"merge_src_transparent": "Прозрачные",
|
||||
"merge_started": "Операция объединения начата",
|
||||
"merge_submit_uncertain": "Узел не подтвердил объединение до разрыва соединения. Оно всё ещё может выполниться — после переподключения проверьте Историю, прежде чем объединять снова.",
|
||||
"merge_title": "Объединить на адрес",
|
||||
"merge_wait_locked": "Кошелёк заблокирован. Разблокируйте его, чтобы продолжить.",
|
||||
"merge_waiting_node": "Ожидание узла…",
|
||||
"merge_where": "Куда направить средства?",
|
||||
"mig_adopt": "Сделать это моим кошельком",
|
||||
"mig_adopt_now": "Принять сид-кошелёк",
|
||||
|
||||
@@ -1178,10 +1178,12 @@
|
||||
"merge_keep_each_status_failed": "%s——失败：%s",
|
||||
"merge_keep_each_status_not_started": "%s——未开始：%s",
|
||||
"merge_keep_each_status_running": "%s——正在合并 %d 张票据（已完成 %d/%d 批）…",
|
||||
"merge_keep_each_status_unconfirmed": "%s——无法确认状态",
|
||||
"merge_keep_each_too_small": "金额太小，无法整合：手续费会耗尽这些资金。",
|
||||
"merge_max_inputs": "每批最大输入数",
|
||||
"merge_no_spendable": "暂无可合并的可用输入。",
|
||||
"merge_progress": "正在合并…这可能需要几分钟。您可以关闭此窗口。",
|
||||
"merge_scope_failed_fmt": "无法读取您的输入：%s",
|
||||
"merge_scope_fmt": "%d 笔透明输入 + %d 笔屏蔽输入 ・ 约 %s DRGX 可用",
|
||||
"merge_scope_loading": "正在检查您的输入…",
|
||||
"merge_send_failed": "合并失败：",
|
||||
@@ -1190,7 +1192,10 @@
|
||||
"merge_src_shielded": "屏蔽",
|
||||
"merge_src_transparent": "透明",
|
||||
"merge_started": "合并操作已开始",
|
||||
"merge_submit_uncertain": "连接中断前节点未确认合并。合并仍可能完成——重新连接后，请先在“历史”中确认，再重新合并。",
|
||||
"merge_title": "合并到地址",
|
||||
"merge_wait_locked": "钱包已锁定。请解锁后继续。",
|
||||
"merge_waiting_node": "正在等待节点…",
|
||||
"merge_where": "资金应转到哪里？",
|
||||
"mig_adopt": "将其设为我的钱包",
|
||||
"mig_adopt_now": "采用助记词钱包",
|
||||
|
||||
+22
-5
@@ -325,6 +325,7 @@ public:
|
||||
|
||||
void beginBackgroundStop(const char* reason) override
|
||||
{
|
||||
app_.abortMaintenanceCalls(); // a long call holds the curl lock disconnect() needs
|
||||
if (app_.rpc_ && app_.rpc_->isConnected()) app_.rpc_->disconnect();
|
||||
app_.onDisconnected(reason ? reason : "Daemon lifecycle");
|
||||
App& app = app_;
|
||||
@@ -1289,13 +1290,28 @@ void App::update()
|
||||
if (!rpc) return [this](){ opid_poll_in_progress_ = false; };
|
||||
json result;
|
||||
services::NetworkRefreshService::OperationStatusPollResult parsed;
|
||||
const auto filter = services::NetworkRefreshService::buildOperationFilterParams(opids);
|
||||
if (!filter) return [this](){ opid_poll_in_progress_ = false; };
|
||||
try {
|
||||
rpc::RPCClient::TraceScope trace("Send tab / Operation status");
|
||||
// No per-opid filter: this daemon rejects z_getoperationstatus(["opid"]) with
|
||||
// "JSON value is not an array as expected", which left completed sends stuck on
|
||||
// "Waiting for operation". The no-arg form returns ALL operations;
|
||||
// parseOperationStatusPoll() filters down to the opids we're tracking.
|
||||
result = rpc->call("z_getoperationstatus", json::array());
|
||||
// Filtered to our opids: the call takes cs_main + cs_wallet and builds a status object for
|
||||
// every op it reports, and the daemon retains finished ops, so the unfiltered form grew
|
||||
// with every send, shield and chat message. Its one argument is an ARRAY of ids,
|
||||
// [[id, ...]]; the old ["opid"] attempt failed with "JSON value is not an array as
|
||||
// expected" because params[0] was a string. If a daemon still answers the filter with an
|
||||
// error, fall back to the unfiltered form for this connection rather than wedge sends on
|
||||
// "Waiting for operation"; parseOperationStatusPoll() ignores ops we don't track.
|
||||
if (!opid_filter_unsupported_.load(std::memory_order_relaxed)) {
|
||||
try {
|
||||
result = rpc->call("z_getoperationstatus", *filter);
|
||||
} catch (const rpc::RpcError& e) {
|
||||
if (e.kind() == rpc::RpcFailureKind::Warmup) throw;
|
||||
result = rpc->call("z_getoperationstatus", json::array());
|
||||
opid_filter_unsupported_.store(true, std::memory_order_relaxed);
|
||||
}
|
||||
} else {
|
||||
result = rpc->call("z_getoperationstatus", json::array());
|
||||
}
|
||||
// Parse INSIDE the guard: a malformed/type-anomalous element must never abort the
|
||||
// poll and leave opid_poll_in_progress_ stuck true for the whole connected session.
|
||||
parsed = services::NetworkRefreshService::parseOperationStatusPoll(result, opids);
|
||||
@@ -7496,6 +7512,7 @@ void App::restartDaemon()
|
||||
|
||||
// Disconnect RPC so the loading overlay appears
|
||||
if (decision.disconnectRpc && rpc_ && rpc_->isConnected()) {
|
||||
abortMaintenanceCalls(); // a long call holds the curl lock disconnect() needs
|
||||
rpc_->disconnect();
|
||||
}
|
||||
onDisconnected("Daemon restart");
|
||||
|
||||
@@ -15,6 +15,8 @@
|
||||
#include <unordered_set>
|
||||
#include <deque>
|
||||
#include <condition_variable>
|
||||
#include <cstdint>
|
||||
#include <optional>
|
||||
#include <nlohmann/json_fwd.hpp>
|
||||
#include "data/transaction_history_cache.h"
|
||||
#include "data/address_book.h"
|
||||
@@ -432,6 +434,42 @@ public:
|
||||
// richer pending-send path internally; this is for operations with no optimistic
|
||||
// transaction row of their own.
|
||||
void trackOperation(const std::string& opid);
|
||||
// The connected daemon rejected the opid-filtered z_getoperationstatus, so polls use the unfiltered
|
||||
// form (every retained op) for the rest of this connection.
|
||||
bool opidFilterUnsupported() const { return opid_filter_unsupported_.load(std::memory_order_relaxed); }
|
||||
|
||||
// RAII around one long ("maintenance") rpc_ call made on a worker thread with a timeout above the
|
||||
// default 30 s, e.g. a merge or a whole-wallet scan given 120 s. rpc_ holds its curl lock for the
|
||||
// whole transfer and disconnect() takes the same lock, so these are counted for
|
||||
// abortMaintenanceCalls().
|
||||
class MaintenanceCallScope {
|
||||
public:
|
||||
explicit MaintenanceCallScope(App& app) : app_(app)
|
||||
{
|
||||
// Count first, then read the flag; abortMaintenanceCalls() sets the flag, then reads the count.
|
||||
// Either this sees the abort and never sends, or the abort sees this call and cuts it off. (A
|
||||
// call queued behind the one disconnect() waits on could otherwise take the curl lock next
|
||||
// and hold disconnect() for its full 120 s.)
|
||||
app_.maint_calls_.fetch_add(1);
|
||||
if (app_.maint_abort_.load()) {
|
||||
app_.maint_calls_.fetch_sub(1);
|
||||
throw rpc::RpcTransportError(rpc::RpcFailureKind::Aborted, "RPC aborted: disconnecting");
|
||||
}
|
||||
}
|
||||
~MaintenanceCallScope() { app_.maint_calls_.fetch_sub(1); }
|
||||
MaintenanceCallScope(const MaintenanceCallScope&) = delete;
|
||||
MaintenanceCallScope& operator=(const MaintenanceCallScope&) = delete;
|
||||
private:
|
||||
App& app_;
|
||||
};
|
||||
// Main thread, right before rpc_->disconnect(): abort rpc_'s in-flight call if it is a maintenance
|
||||
// call, so the disconnect doesn't freeze the UI for up to its 120 s, and refuse maintenance calls that
|
||||
// start before the next connect (onConnected() lifts that). Ordinary calls are left to finish (at most
|
||||
// 30 s, as before), so a user's own send is never cut off mid-call.
|
||||
void abortMaintenanceCalls();
|
||||
// Whether a whole-wallet scan the user didn't ask for may be sent now: a connected, unlocked, synced
|
||||
// full node that is past warmup, not rescanning and not busy.
|
||||
bool walletScanReady() const;
|
||||
|
||||
// Force refresh
|
||||
void refreshNow();
|
||||
@@ -738,14 +776,18 @@ private:
|
||||
// t_addresses for `fromAddress` and clamp its balance at >=0. A positive `signedAmount`
|
||||
// restores a debit; a negative one applies it. When `includeAggregates` is set, adjust the
|
||||
// private/transparent bucket (chosen by the address's leading 'z') and totalBalance with the
|
||||
// same clamp. Shared by the three pending-send delta sites so they can't drift.
|
||||
// same clamp. Shared by the three pending-send delta sites so they can't drift. `includeAddress`
|
||||
// off leaves the per-address balances alone (the Core poll refreshes only the aggregates).
|
||||
void applyPendingSendDelta(const std::string& fromAddress, double signedAmount,
|
||||
bool includeAggregates);
|
||||
bool includeAggregates, bool includeAddress = true);
|
||||
// Deliver a deferred z_sendmany result to its waiting UI callback once the opid
|
||||
// reaches a terminal status. Returns true if a callback was registered (and fired).
|
||||
bool invokeSendResultCallback(const std::string& opid, bool ok,
|
||||
const std::string& result);
|
||||
void applyPendingSendBalanceDeltas(bool includeAggregateBalances);
|
||||
// Re-apply every pending send's debit on top of freshly fetched balances: the aggregates after a
|
||||
// Core poll that carried a balance, the per-address balances after an address scan. Only onto
|
||||
// fresh values, or a debit applied again on every tick would drain them.
|
||||
void applyPendingSendBalanceDeltas(bool includeAggregateBalances, bool includeAddressBalances = true);
|
||||
std::string transactionHistoryCacheWalletIdentity() const;
|
||||
bool ensureTransactionHistoryCacheUnlockedFor(const std::string& walletIdentity);
|
||||
// Record the active wallet's cached metadata (balance, address count, identity, size) into the
|
||||
@@ -1302,6 +1344,16 @@ private:
|
||||
std::time_t sync_settle_until_ = 0; // hold the sync-throttle until this wall-clock time (0 = not settling)
|
||||
double last_balance_scan_ms_ = 0.0; // measured cost of the last z_gettotalbalance scan
|
||||
bool force_balance_refresh_ = false; // a wallet mutation forces the next balance poll through the throttle
|
||||
// Bumped with each forced-refresh request, so the poll that carried the forced balance clears the
|
||||
// flag only if no newer request came in meanwhile (see requestForcedBalanceRefresh()).
|
||||
std::uint32_t force_balance_seq_ = 0;
|
||||
// The exact minconf=0 total of the last balance poll: the minconf=1 call is skipped while it holds
|
||||
// still and nothing is pending (NetworkRefreshService::CoreRefreshPlan).
|
||||
std::optional<std::int64_t> last_total_balance_zat_;
|
||||
// Force the next balance poll through the throttle (the user's own send). Cleared by the Core poll
|
||||
// that actually sent the forced balance call, not at dispatch, so a dispatch the job queue refuses
|
||||
// (a Core job already in flight) or one that skips the balance (node behind or busy) keeps it.
|
||||
void requestForcedBalanceRefresh() { force_balance_refresh_ = true; ++force_balance_seq_; }
|
||||
// Same adaptive back-off applied to the other two O(mapWallet) scans that hold the daemon's cs_main:
|
||||
// the address scan (z_listunspent) and the history scan (z_listreceivedbyaddress). Without this, a
|
||||
// large shielded wallet re-scans them every tab cadence (~seconds each), saturating cs_main and
|
||||
@@ -1490,6 +1542,9 @@ private:
|
||||
std::unordered_set<std::string> witness_seen_txids_;
|
||||
int witness_total_txs_ = 0;
|
||||
bool opid_poll_in_progress_ = false;
|
||||
std::atomic<bool> opid_filter_unsupported_{false}; // see opidFilterUnsupported(); set on the worker
|
||||
std::atomic<int> maint_calls_{0}; // maintenance calls in flight (MaintenanceCallScope)
|
||||
std::atomic<bool> maint_abort_{false}; // set by abortMaintenanceCalls(), cleared on connect
|
||||
// Consecutive Core-refresh cycles where BOTH core RPCs failed → likely a dead
|
||||
// connection. After kCoreFailuresBeforeDisconnect, tear down and reconnect.
|
||||
int consecutive_core_failures_ = 0;
|
||||
|
||||
+54
-10
@@ -687,7 +687,9 @@ void App::tryConnect()
|
||||
|
||||
void App::onConnected()
|
||||
{
|
||||
maint_abort_.store(false); // maintenance calls queued before this connect have already failed (FIFO)
|
||||
state_.connected = true;
|
||||
ui::ShieldDialog::invalidateScope(); // inputs read before this connect may be another wallet's
|
||||
const bool completedSwitch = wallet_switch_pending_confirm_.exchange(false); // this connect confirms a switch
|
||||
// A successful connect completes a switch — close/clear the progress modal (kept open through the
|
||||
// stop → start → reconnect sequence, or already hidden via "continue in background").
|
||||
@@ -837,6 +839,9 @@ void App::onDisconnected(const std::string& reason)
|
||||
network_refresh_.resetJobs();
|
||||
rescan_status_poll_in_progress_ = false;
|
||||
opid_poll_in_progress_ = false;
|
||||
opid_filter_unsupported_ = false; // a reconnect may be to a different daemon
|
||||
last_total_balance_zat_.reset();
|
||||
ui::ShieldDialog::invalidateScope();
|
||||
address_validation_cache_dirty_ = true;
|
||||
resetTransactionHistoryCacheSession();
|
||||
|
||||
@@ -937,6 +942,7 @@ void App::handleLostConnection(const std::string& reason)
|
||||
DEBUG_LOGF("[Connection] %s — tearing down for reconnect\n", reason.c_str());
|
||||
// Flip the main client's connected_ flag so update()'s else-branch re-enters
|
||||
// tryConnect(). onDisconnected() alone only tears down the fast lane.
|
||||
abortMaintenanceCalls(); // a long call holds the curl lock disconnect() needs
|
||||
if (rpc_) rpc_->disconnect();
|
||||
onDisconnected(reason);
|
||||
}
|
||||
@@ -989,6 +995,24 @@ bool App::effectivelySyncing() const
|
||||
return std::time(nullptr) < sync_settle_until_;
|
||||
}
|
||||
|
||||
void App::abortMaintenanceCalls()
|
||||
{
|
||||
// Both stick until the next connect, which is fine here: every caller disconnects next.
|
||||
maint_abort_.store(true); // refuses maintenance calls still queued on the worker
|
||||
if (rpc_ && maint_calls_.load() > 0) rpc_->requestAbort(); // cuts off the one in flight
|
||||
}
|
||||
|
||||
bool App::walletScanReady() const
|
||||
{
|
||||
if (isLiteBuild() || capture_mode_ || shutting_down_.load()) return false;
|
||||
// state_.warming_up, not rpc_->isWarmingUp(): the client's flag is set when a connect lands in warmup
|
||||
// and stays set until the next reconnect, which kept this false for the whole session.
|
||||
if (!rpc_ || !rpc_->isConnected()) return false;
|
||||
if (!state_.connected || state_.warming_up || state_.isLocked()) return false;
|
||||
if (state_.sync.rescanning || runtime_rescan_active_ || effectivelySyncing()) return false;
|
||||
return !rpc_busy_gate_->busy();
|
||||
}
|
||||
|
||||
// Adaptive throttle: the next balance poll must wait at least (lastScanCost / kBalanceDutyCycle) since
|
||||
// the last one, so balance scanning can never occupy more than ~kBalanceDutyCycle of wall-clock. A
|
||||
// cheap wallet (sub-cadence cost) is unaffected — the tab's Core timer stays the real cadence; a ~20s
|
||||
@@ -1194,7 +1218,7 @@ void App::removePendingSendTransactions(const std::vector<std::string>& opids,
|
||||
}
|
||||
|
||||
void App::applyPendingSendDelta(const std::string& fromAddress, double signedAmount,
|
||||
bool includeAggregates)
|
||||
bool includeAggregates, bool includeAddress)
|
||||
{
|
||||
// For a debit (signedAmount < 0) this clamps at >=0 exactly as the debit sites did. For a
|
||||
// restore (signedAmount > 0) the clamp is a no-op — max(0, bal+amt) == bal+amt when bal,amt>=0 —
|
||||
@@ -1211,7 +1235,7 @@ void App::applyPendingSendDelta(const std::string& fromAddress, double signedAmo
|
||||
}
|
||||
return false;
|
||||
};
|
||||
if (!applyToAddress(state_.z_addresses)) applyToAddress(state_.t_addresses);
|
||||
if (includeAddress && !applyToAddress(state_.z_addresses)) applyToAddress(state_.t_addresses);
|
||||
if (includeAggregates) {
|
||||
if (!fromAddress.empty() && fromAddress[0] == 'z') {
|
||||
state_.spendablePrivateBalance = std::max(0.0, state_.spendablePrivateBalance + signedAmount);
|
||||
@@ -1244,11 +1268,11 @@ bool App::invokeSendResultCallback(const std::string& opid, bool ok,
|
||||
return true;
|
||||
}
|
||||
|
||||
void App::applyPendingSendBalanceDeltas(bool includeAggregateBalances)
|
||||
void App::applyPendingSendBalanceDeltas(bool includeAggregateBalances, bool includeAddressBalances)
|
||||
{
|
||||
for (const auto& [opid, pending] : pending_send_info_) {
|
||||
(void)opid;
|
||||
applyPendingSendDelta(pending.from, -pending.amount, includeAggregateBalances);
|
||||
applyPendingSendDelta(pending.from, -pending.amount, includeAggregateBalances, includeAddressBalances);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1458,6 +1482,7 @@ void App::switchToWallet(const std::string& walletFile, bool stopDaemonConfirmed
|
||||
// start, so the daemon comes up on -wallet=<name>. WalletState clears on disconnect and the
|
||||
// per-wallet caches re-key off the new identity (P1), so no previous-wallet data leaks through.
|
||||
daemon_restarting_ = true;
|
||||
abortMaintenanceCalls(); // a long call holds the curl lock disconnect() needs
|
||||
if (rpc_ && rpc_->isConnected()) rpc_->disconnect();
|
||||
onDisconnected("Switching wallet");
|
||||
// The loaded wallet is changing — drop the old wallet's chat identity + decrypted store so it
|
||||
@@ -1885,15 +1910,31 @@ void App::refreshCoreData(bool allowBalance)
|
||||
// pending for after the unlock.
|
||||
const bool includeBalance = allowBalance && !effectivelySyncing() &&
|
||||
(force_balance_refresh_ || balanceRefreshDue());
|
||||
if (includeBalance) force_balance_refresh_ = false;
|
||||
// The forced request this poll carries. The result callback clears the flag only if the balance
|
||||
// call was really sent and no newer request came in; clearing it here lost it whenever the enqueue
|
||||
// was refused (a Core job already in flight) or the worker skipped the balance (behind, busy).
|
||||
const std::uint32_t forcedSeq = (includeBalance && force_balance_refresh_) ? force_balance_seq_ : 0;
|
||||
NetworkRefreshService::CoreRefreshPlan plan;
|
||||
plan.includeBalance = includeBalance;
|
||||
plan.needSpendable = NetworkRefreshService::spendableBalanceNeeded(
|
||||
state_, !pending_send_info_.empty() || !pending_opids_.empty() || !send_txids_.empty(),
|
||||
force_balance_refresh_);
|
||||
plan.prevTotalZat = last_total_balance_zat_;
|
||||
|
||||
auto enqueued = network_refresh_.enqueue(services::NetworkRefreshService::Job::Core, *w, [this, rpc, tracePage, includeBalance]() -> rpc::RPCWorker::MainCb {
|
||||
auto enqueued = network_refresh_.enqueue(services::NetworkRefreshService::Job::Core, *w, [this, rpc, tracePage, plan, forcedSeq]() -> rpc::RPCWorker::MainCb {
|
||||
AppRefreshRpcGateway refreshRpc(*rpc, traceSource(tracePage, "Core refresh"));
|
||||
auto result = NetworkRefreshService::collectCoreRefreshResult(refreshRpc, includeBalance);
|
||||
return [this, result]() {
|
||||
auto result = NetworkRefreshService::collectCoreRefreshResult(refreshRpc, plan);
|
||||
return [this, result, forcedSeq]() {
|
||||
try {
|
||||
NetworkRefreshService::applyCoreRefreshResult(state_, result, std::time(nullptr));
|
||||
applyPendingSendBalanceDeltas(true);
|
||||
if (result.balanceOk) {
|
||||
// Fresh aggregates: re-apply the pending sends' debits to them. The per-address
|
||||
// balances are the address scan's to refresh and re-debit.
|
||||
applyPendingSendBalanceDeltas(true, false);
|
||||
}
|
||||
last_total_balance_zat_ = NetworkRefreshService::nextTotalBaseline(result, last_total_balance_zat_);
|
||||
if (forcedSeq != 0 && result.balanceAttempted && forcedSeq == force_balance_seq_)
|
||||
force_balance_refresh_ = false;
|
||||
|
||||
// Feed the adaptive balance throttle + sync-settle hysteresis. Record the last scan's
|
||||
// cost (0 when balance was skipped), and arm the settle window only on the
|
||||
@@ -5182,6 +5223,7 @@ void App::beginAdoptSeedWallet()
|
||||
{ std::lock_guard<std::mutex> lk(seed_migration_mutex_); seed_migration_adopt_done_ = false; }
|
||||
// Gate the main-loop reconnect so tryConnect can't start the daemon while we swap wallet.dat.
|
||||
daemon_restarting_ = true;
|
||||
abortMaintenanceCalls(); // a long call holds the curl lock disconnect() needs
|
||||
if (rpc_ && rpc_->isConnected()) rpc_->disconnect();
|
||||
onDisconnected("Adopting seed wallet");
|
||||
// Adopting swaps in a brand-new seed wallet — drop the legacy wallet's chat identity + store so
|
||||
@@ -5302,6 +5344,7 @@ void App::restoreOriginalWallet()
|
||||
{ std::lock_guard<std::mutex> lk(wallet_restore_mutex_); wallet_restore_done_ = false; }
|
||||
daemon_restarting_ = true; // gate the reconnect loop while we swap files
|
||||
connection_status_ = TR("sb_restarting_daemon");
|
||||
abortMaintenanceCalls(); // a long call holds the curl lock disconnect() needs
|
||||
if (rpc_ && rpc_->isConnected()) rpc_->disconnect();
|
||||
onDisconnected("Restoring original wallet");
|
||||
ui::Notifications::instance().info(TR("wallet_restore_started"), 12.0f);
|
||||
@@ -5472,6 +5515,7 @@ void App::rebuildWalletDatabase()
|
||||
{ std::lock_guard<std::mutex> lk(wallet_restore_mutex_); wallet_restore_done_ = false; }
|
||||
daemon_restarting_ = true;
|
||||
connection_status_ = TR("sb_restarting_daemon");
|
||||
abortMaintenanceCalls(); // a long call holds the curl lock disconnect() needs
|
||||
if (rpc_ && rpc_->isConnected()) rpc_->disconnect();
|
||||
onDisconnected("Rebuilding wallet database");
|
||||
ui::Notifications::instance().info(TR("wallet_rebuild_started"), 15.0f);
|
||||
@@ -5813,7 +5857,7 @@ void App::submitZSendMany(const std::string& from, const std::string& to, double
|
||||
// Force transaction list refresh so the sent tx appears immediately
|
||||
transactions_dirty_ = true;
|
||||
last_tx_block_height_ = -1;
|
||||
force_balance_refresh_ = true; // the user's own send must update the balance now, past the throttle
|
||||
requestForcedBalanceRefresh(); // the user's own send must update the balance now, past the throttle
|
||||
network_refresh_.markWalletMutationRefresh();
|
||||
// z_sendmany only returned an opid: the transaction is built/signed/
|
||||
// broadcast asynchronously by the daemon. Defer the user-facing
|
||||
|
||||
@@ -87,6 +87,7 @@ void App::restartWizard()
|
||||
|
||||
// Disconnect RPC
|
||||
if (rpc_ && rpc_->isConnected()) {
|
||||
abortMaintenanceCalls(); // a long call holds the curl lock disconnect() needs
|
||||
rpc_->disconnect();
|
||||
}
|
||||
onDisconnected("Wizard restart");
|
||||
|
||||
@@ -832,24 +832,6 @@ void RPCClient::z_mergeToAddress(const std::vector<std::string>& fromAddrs, cons
|
||||
doRPC("z_mergetoaddress", {addrs, toAddr, fee, 0, limit}, cb, err);
|
||||
}
|
||||
|
||||
void RPCClient::z_getOperationStatus(const std::vector<std::string>& opids, Callback cb, ErrorCallback err)
|
||||
{
|
||||
json ids = json::array();
|
||||
for (const auto& id : opids) {
|
||||
ids.push_back(id);
|
||||
}
|
||||
doRPC("z_getoperationstatus", {ids}, cb, err);
|
||||
}
|
||||
|
||||
void RPCClient::z_getOperationResult(const std::vector<std::string>& opids, Callback cb, ErrorCallback err)
|
||||
{
|
||||
json ids = json::array();
|
||||
for (const auto& id : opids) {
|
||||
ids.push_back(id);
|
||||
}
|
||||
doRPC("z_getoperationresult", {ids}, cb, err);
|
||||
}
|
||||
|
||||
void RPCClient::z_listReceivedByAddress(const std::string& address, int minconf, Callback cb, ErrorCallback err)
|
||||
{
|
||||
doRPC("z_listreceivedbyaddress", {address, minconf}, cb, err);
|
||||
@@ -902,16 +884,6 @@ void RPCClient::z_mergeToAddress(const std::vector<std::string>& fromAddrs, cons
|
||||
doRPC("z_mergetoaddress", {addrs, toAddr, fee, 0, limit}, handlers.first, handlers.second);
|
||||
}
|
||||
|
||||
void RPCClient::z_getOperationStatus(const std::vector<std::string>& opids, UnifiedCallback cb)
|
||||
{
|
||||
json ids = json::array();
|
||||
for (const auto& id : opids) {
|
||||
ids.push_back(id);
|
||||
}
|
||||
auto handlers = splitUnified(std::move(cb));
|
||||
doRPC("z_getoperationstatus", {ids}, handlers.first, handlers.second);
|
||||
}
|
||||
|
||||
void RPCClient::getBlock(int height, UnifiedCallback cb)
|
||||
{
|
||||
// First get block hash, then get block
|
||||
|
||||
@@ -257,10 +257,6 @@ public:
|
||||
void z_mergeToAddress(const std::vector<std::string>& fromAddrs, const std::string& toAddr,
|
||||
double fee, int limit, Callback cb, ErrorCallback err = nullptr);
|
||||
|
||||
// Operation status monitoring
|
||||
void z_getOperationStatus(const std::vector<std::string>& opids, Callback cb, ErrorCallback err = nullptr);
|
||||
void z_getOperationResult(const std::vector<std::string>& opids, Callback cb, ErrorCallback err = nullptr);
|
||||
|
||||
// Received transactions
|
||||
void z_listReceivedByAddress(const std::string& address, int minconf, Callback cb, ErrorCallback err = nullptr);
|
||||
|
||||
@@ -272,7 +268,6 @@ public:
|
||||
double fee, int limit, UnifiedCallback cb);
|
||||
void z_mergeToAddress(const std::vector<std::string>& fromAddrs, const std::string& toAddr,
|
||||
double fee, int limit, UnifiedCallback cb);
|
||||
void z_getOperationStatus(const std::vector<std::string>& opids, UnifiedCallback cb);
|
||||
void getBlock(int height, UnifiedCallback cb);
|
||||
|
||||
private:
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
#include <chrono>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <limits>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <unordered_map>
|
||||
@@ -271,6 +272,9 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::parseCoreRefresh
|
||||
result.shieldedBalance = readBalanceString(totalBalance, "private");
|
||||
result.transparentBalance = readBalanceString(totalBalance, "transparent");
|
||||
result.totalBalance = readBalanceString(totalBalance, "total");
|
||||
const auto total = totalBalance.find("total");
|
||||
if (total != totalBalance.end() && total->is_string())
|
||||
result.totalBalanceZat = parseMoneyZat(total->get<std::string>());
|
||||
}
|
||||
if (spendableBalance.is_object()) { // confirmed totals (minconf=1); left unset on old daemons
|
||||
result.spendableShieldedBalance = readBalanceString(spendableBalance, "private");
|
||||
@@ -290,7 +294,8 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::parseCoreRefresh
|
||||
return result;
|
||||
}
|
||||
|
||||
NetworkRefreshService::CoreRefreshResult NetworkRefreshService::collectCoreRefreshResult(RefreshRpcGateway& rpc, bool includeBalance)
|
||||
NetworkRefreshService::CoreRefreshResult NetworkRefreshService::collectCoreRefreshResult(RefreshRpcGateway& rpc,
|
||||
const CoreRefreshPlan& plan)
|
||||
{
|
||||
json totalBalance;
|
||||
json spendableBalance;
|
||||
@@ -328,7 +333,9 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::collectCoreRefre
|
||||
|
||||
// Don't follow a chain-info call that found the node busy (a reply timeout or a full queue) with two
|
||||
// balance scans: they need the same cs_main, and each would only take another of its few RPC slots.
|
||||
if (includeBalance && !behind && !rpc::rpcKindMeansBusy(blockErrKind)) {
|
||||
bool balanceAttempted = false;
|
||||
bool spendableQueried = false;
|
||||
if (plan.includeBalance && !behind && !rpc::rpcKindMeansBusy(blockErrKind)) {
|
||||
// z_gettotalbalance is O(mapWallet) and holds the daemon's cs_main for its whole duration —
|
||||
// seconds on a large shielded wallet. Time it so the caller can throttle how often it polls
|
||||
// (balanceRefreshDue()), keeping balance scans from starving block connection.
|
||||
@@ -340,9 +347,25 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::collectCoreRefre
|
||||
balanceErrKind = rpc::rpcFailureKindOf(e);
|
||||
DEBUG_LOGF("Balance error: %s\n", e.what());
|
||||
}
|
||||
try { // SPENDABLE total: minconf=1 (confirmed). If absent, spendable degrades to display in apply.
|
||||
spendableBalance = rpc.call("z_gettotalbalance", json::array({1}));
|
||||
} catch (...) {}
|
||||
// A Deferred call was held back by the busy gate and never reached the daemon.
|
||||
balanceAttempted = balanceErrKind != rpc::RpcFailureKind::Deferred;
|
||||
// SPENDABLE total: minconf=1 (confirmed), a second whole-wallet scan. Only after the display call
|
||||
// succeeded (its result is dropped otherwise), and only when it can differ from the display total:
|
||||
// something is unconfirmed or pending (needSpendable), or the exact total moved since the last
|
||||
// poll, which is how a new incoming 0-conf payment first shows. Skipped, spendable equals display
|
||||
// in applyCoreRefreshResult and nothing reads as unconfirmed.
|
||||
if (balanceOk) {
|
||||
std::optional<std::int64_t> totalZat;
|
||||
const auto total = totalBalance.is_object() ? totalBalance.find("total") : totalBalance.end();
|
||||
if (total != totalBalance.end() && total->is_string()) totalZat = parseMoneyZat(total->get<std::string>());
|
||||
const bool totalMoved = !totalZat || !plan.prevTotalZat || *totalZat != *plan.prevTotalZat;
|
||||
if (plan.needSpendable || totalMoved) {
|
||||
spendableQueried = true;
|
||||
try { // If it fails, spendable degrades to display in apply.
|
||||
spendableBalance = rpc.call("z_gettotalbalance", json::array({1}));
|
||||
} catch (...) {}
|
||||
}
|
||||
}
|
||||
balanceScanMs = std::chrono::duration<double, std::milli>(
|
||||
std::chrono::steady_clock::now() - balanceStart).count();
|
||||
}
|
||||
@@ -351,9 +374,65 @@ NetworkRefreshService::CoreRefreshResult NetworkRefreshService::collectCoreRefre
|
||||
result.balanceScanMs = balanceScanMs;
|
||||
result.blockchainErrKind = blockErrKind;
|
||||
result.balanceErrKind = balanceErrKind;
|
||||
result.balanceAttempted = balanceAttempted;
|
||||
result.spendableQueried = spendableQueried;
|
||||
return result;
|
||||
}
|
||||
|
||||
std::optional<std::int64_t> NetworkRefreshService::parseMoneyZat(const std::string& text)
|
||||
{
|
||||
constexpr std::int64_t kCoin = 100000000;
|
||||
// Leaves room for up to 99999999 zatoshis of fraction on top of whole * 1e8.
|
||||
constexpr std::int64_t kMaxWhole = std::numeric_limits<std::int64_t>::max() / kCoin - 1;
|
||||
std::size_t i = 0;
|
||||
const bool negative = !text.empty() && text[0] == '-';
|
||||
if (negative) ++i;
|
||||
std::int64_t whole = 0;
|
||||
std::size_t wholeDigits = 0;
|
||||
for (; i < text.size() && text[i] >= '0' && text[i] <= '9'; ++i, ++wholeDigits) {
|
||||
const int digit = text[i] - '0';
|
||||
if (whole > (kMaxWhole - digit) / 10) return std::nullopt; // the amount would overflow
|
||||
whole = whole * 10 + digit;
|
||||
}
|
||||
if (wholeDigits == 0) return std::nullopt;
|
||||
std::int64_t fraction = 0;
|
||||
if (i < text.size() && text[i] == '.') {
|
||||
++i;
|
||||
std::size_t fractionDigits = 0;
|
||||
for (; i < text.size() && text[i] >= '0' && text[i] <= '9'; ++i, ++fractionDigits) {
|
||||
if (fractionDigits == 8) return std::nullopt; // finer than a zatoshi: not a daemon amount
|
||||
fraction = fraction * 10 + (text[i] - '0');
|
||||
}
|
||||
if (fractionDigits == 0) return std::nullopt;
|
||||
for (; fractionDigits < 8; ++fractionDigits) fraction *= 10;
|
||||
}
|
||||
if (i != text.size()) return std::nullopt;
|
||||
const std::int64_t zat = whole * kCoin + fraction;
|
||||
return negative ? -zat : zat;
|
||||
}
|
||||
|
||||
std::optional<std::int64_t> NetworkRefreshService::nextTotalBaseline(const CoreRefreshResult& result,
|
||||
std::optional<std::int64_t> previous)
|
||||
{
|
||||
if (!result.balanceOk) return previous; // no fresh total
|
||||
if (result.spendableQueried && !result.spendableTotalBalance) return std::nullopt; // re-measure next poll
|
||||
return result.totalBalanceZat;
|
||||
}
|
||||
|
||||
bool NetworkRefreshService::spendableBalanceNeeded(const WalletState& state, bool pendingSendWork, bool forced)
|
||||
{
|
||||
if (forced || pendingSendWork) return true;
|
||||
if (state.last_balance_update == 0) return true;
|
||||
if (state.unconfirmedBalance > 1e-9) return true;
|
||||
// The address scan saw unconfirmed funds (z_listunspent/listunspent at minconf=0 with confirmations).
|
||||
auto anyUnconfirmed = [](const std::vector<AddressInfo>& addresses) {
|
||||
return std::any_of(addresses.begin(), addresses.end(), [](const AddressInfo& address) {
|
||||
return address.balance - address.spendableBalance > 1e-9;
|
||||
});
|
||||
};
|
||||
return anyUnconfirmed(state.z_addresses) || anyUnconfirmed(state.t_addresses);
|
||||
}
|
||||
|
||||
NetworkRefreshService::MiningRefreshResult NetworkRefreshService::parseMiningRefreshResult(
|
||||
const json& miningInfo, bool miningOk, const json& localHashrate, bool hashrateOk, double daemonMemoryMb)
|
||||
{
|
||||
@@ -1327,9 +1406,10 @@ NetworkRefreshService::OperationStatusPollResult NetworkRefreshService::parseOpe
|
||||
OperationStatusPollResult parsed;
|
||||
if (!result.is_array()) return parsed;
|
||||
|
||||
// We poll z_getoperationstatus with no filter (this daemon rejects the per-opid filtered form),
|
||||
// so the result lists ALL operations. Only act on the ones we're tracking — otherwise an
|
||||
// unrelated failed/old operation would fire a spurious error toast or pollute send state.
|
||||
// The poll is filtered to our opids (buildOperationFilterParams), but falls back to the unfiltered
|
||||
// form, which lists ALL operations, if a daemon rejects the filter. Only act on the ones we're
|
||||
// tracking — otherwise an unrelated failed/old operation would fire a spurious error toast or
|
||||
// pollute send state.
|
||||
const std::set<std::string> requested(requestedOpids.begin(), requestedOpids.end());
|
||||
|
||||
std::set<std::string> reported;
|
||||
@@ -1379,6 +1459,18 @@ NetworkRefreshService::OperationStatusPollResult NetworkRefreshService::parseOpe
|
||||
return parsed;
|
||||
}
|
||||
|
||||
std::optional<json> NetworkRefreshService::buildOperationFilterParams(const std::vector<std::string>& opids)
|
||||
{
|
||||
json ids = json::array();
|
||||
for (const auto& opid : opids) {
|
||||
if (!opid.empty()) ids.push_back(opid);
|
||||
}
|
||||
if (ids.empty()) return std::nullopt;
|
||||
json params = json::array();
|
||||
params.push_back(std::move(ids));
|
||||
return params;
|
||||
}
|
||||
|
||||
void NetworkRefreshService::applyConnectionInfoResult(WalletState& state, const ConnectionInfoResult& result)
|
||||
{
|
||||
if (!result.ok) return;
|
||||
|
||||
@@ -120,6 +120,20 @@ public:
|
||||
// node (ReplyTimeout / QueueFull) from a gone one (NotListening) without reading what().
|
||||
rpc::RpcFailureKind blockchainErrKind = rpc::RpcFailureKind::None;
|
||||
rpc::RpcFailureKind balanceErrKind = rpc::RpcFailureKind::None;
|
||||
// The minconf=0 call reached the daemon (it may still have failed). False when the balance was
|
||||
// skipped (behind, busy chain read) or held back by the busy gate (Deferred) before it was sent.
|
||||
bool balanceAttempted = false;
|
||||
bool spendableQueried = false; // the minconf=1 call was made
|
||||
std::optional<std::int64_t> totalBalanceZat; // the minconf=0 "total" in zatoshis, exact
|
||||
};
|
||||
|
||||
// What one Core refresh fetches. The minconf=1 (spendable) z_gettotalbalance is a second whole-wallet
|
||||
// scan under cs_main; it only tells something the minconf=0 call doesn't while funds are unconfirmed
|
||||
// or pending, so it runs only when needSpendable or the exact total moved since prevTotalZat.
|
||||
struct CoreRefreshPlan {
|
||||
bool includeBalance = true;
|
||||
bool needSpendable = true;
|
||||
std::optional<std::int64_t> prevTotalZat;
|
||||
};
|
||||
|
||||
struct MiningRefreshResult {
|
||||
@@ -271,7 +285,24 @@ public:
|
||||
// includeBalance=false skips z_gettotalbalance (which takes the wallet lock + cs_main) and only
|
||||
// fetches getblockchaininfo — used while syncing, where the balance is incomplete anyway and the
|
||||
// wallet should minimise lock contention with block connection.
|
||||
static CoreRefreshResult collectCoreRefreshResult(RefreshRpcGateway& rpc, bool includeBalance = true);
|
||||
static CoreRefreshResult collectCoreRefreshResult(RefreshRpcGateway& rpc, const CoreRefreshPlan& plan);
|
||||
static CoreRefreshResult collectCoreRefreshResult(RefreshRpcGateway& rpc, bool includeBalance = true)
|
||||
{
|
||||
CoreRefreshPlan plan;
|
||||
plan.includeBalance = includeBalance;
|
||||
return collectCoreRefreshResult(rpc, plan);
|
||||
}
|
||||
// An amount as the daemon formats it ("[-]digits[.up to 8 digits]") in zatoshis; nullopt for anything
|
||||
// else or anything that would overflow. Exact, so "did the total move" never trips on rounding.
|
||||
static std::optional<std::int64_t> parseMoneyZat(const std::string& text);
|
||||
// Whether the next balance poll needs the minconf=1 (spendable) call whatever the total does: never
|
||||
// fetched, unconfirmed or pending funds, or a forced refresh after the user's own send.
|
||||
static bool spendableBalanceNeeded(const WalletState& state, bool pendingSendWork, bool forced);
|
||||
// The total the next poll compares against (CoreRefreshPlan::prevTotalZat). None after a poll whose
|
||||
// minconf=1 call was made but brought back no total (timeout, held back, error): that left spendable
|
||||
// degraded to display, so the next poll must count the total as moved and measure it again.
|
||||
static std::optional<std::int64_t> nextTotalBaseline(const CoreRefreshResult& result,
|
||||
std::optional<std::int64_t> previous);
|
||||
static MiningRefreshResult parseMiningRefreshResult(const nlohmann::json& miningInfo,
|
||||
bool miningOk,
|
||||
const nlohmann::json& localHashrate,
|
||||
@@ -340,6 +371,11 @@ public:
|
||||
int pageSize = 100);
|
||||
static OperationStatusPollResult parseOperationStatusPoll(const nlohmann::json& result,
|
||||
const std::vector<std::string>& requestedOpids);
|
||||
// Params for z_getoperationstatus/result filtered to these opids: ONE argument, an array of ids, so
|
||||
// [[id, ...]]. nullopt when no non-empty id remains: an empty filter means every op the node has
|
||||
// retained. Built explicitly, because a one-element braced list of a json ({ids}) collapses to the
|
||||
// inner array, which the daemon rejects ("JSON value is not an array as expected").
|
||||
static std::optional<nlohmann::json> buildOperationFilterParams(const std::vector<std::string>& opids);
|
||||
|
||||
struct DaemonRescanScan {
|
||||
bool foundRescan = false;
|
||||
|
||||
@@ -5,6 +5,7 @@
|
||||
#include "note_consolidation.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cctype>
|
||||
#include <map>
|
||||
|
||||
namespace dragonx {
|
||||
@@ -20,6 +21,7 @@ std::vector<NoteGroup> groupSpendableNotes(const nlohmann::json& zListUnspent)
|
||||
if (address.empty()) continue;
|
||||
if (n.value("confirmations", 0) < 1) continue; // z_mergetoaddress spends confirmed notes only
|
||||
if (!n.value("spendable", true)) continue; // watch-only: no key to spend it
|
||||
if (noteIsLocked(n)) continue; // held by an operation in flight
|
||||
NoteGroup& g = byAddress[address];
|
||||
g.address = address;
|
||||
++g.notes;
|
||||
@@ -36,6 +38,13 @@ std::vector<NoteGroup> groupSpendableNotes(const nlohmann::json& zListUnspent)
|
||||
return out;
|
||||
}
|
||||
|
||||
bool noteIsLocked(const nlohmann::json& zListUnspentEntry)
|
||||
{
|
||||
if (!zListUnspentEntry.is_object()) return false;
|
||||
const auto it = zListUnspentEntry.find("locked");
|
||||
return it != zListUnspentEntry.end() && it->is_boolean() && it->get<bool>();
|
||||
}
|
||||
|
||||
bool worthConsolidating(const NoteGroup& group, double fee)
|
||||
{
|
||||
// The daemon rejects a merge whose fee is more than what it nets (merged value < 2 x fee).
|
||||
@@ -67,5 +76,107 @@ AddressRun consolidateInPlace(const std::string& address, const MergeCall& call,
|
||||
return run;
|
||||
}
|
||||
|
||||
ScopeWant scopeScanWant(const ScopeScan& scan, const ScopeInputs& in)
|
||||
{
|
||||
if (!in.mergeMode || scan.phase == ScopePhase::Loaded) return ScopeWant::Nothing;
|
||||
if (scan.inFlight || in.busyWithOp) return ScopeWant::Nothing;
|
||||
if (scan.phase == ScopePhase::Failed && !scan.autoRetry) return ScopeWant::Nothing; // waits for Retry
|
||||
if (in.now < scan.retryAt) return ScopeWant::WaitBackoff;
|
||||
if (!in.nodeReady) return ScopeWant::WaitNode;
|
||||
return ScopeWant::Post;
|
||||
}
|
||||
|
||||
std::uint32_t scopeScanBegin(ScopeScan& scan, double now)
|
||||
{
|
||||
scan.phase = ScopePhase::Loading;
|
||||
scan.inFlight = true;
|
||||
scan.inFlightGen = scan.gen;
|
||||
scan.startedAt = now;
|
||||
return scan.gen;
|
||||
}
|
||||
|
||||
bool scopeScanFinish(ScopeScan& scan, std::uint32_t gen, const std::string& error, rpc::RpcFailureKind kind,
|
||||
double now)
|
||||
{
|
||||
if (scan.inFlight && gen == scan.inFlightGen) scan.inFlight = false;
|
||||
if (gen != scan.gen) return false; // a scan from an earlier session: its data is not this one's
|
||||
if (error.empty()) {
|
||||
scan.phase = ScopePhase::Loaded;
|
||||
scan.failures = 0;
|
||||
scan.autoRetry = false;
|
||||
scan.retryAt = 0.0;
|
||||
scan.error.clear();
|
||||
return true;
|
||||
}
|
||||
scan.phase = ScopePhase::Failed;
|
||||
++scan.failures;
|
||||
scan.error = error;
|
||||
scan.autoRetry = scopeFailureRetries(kind, error) && scan.failures <= kScopeMaxAutoRetries;
|
||||
scan.retryAt = scan.autoRetry ? now + scopeRetryDelaySec(scan.failures) : 0.0;
|
||||
return false;
|
||||
}
|
||||
|
||||
void scopeScanOpen(ScopeScan& scan, double now)
|
||||
{
|
||||
if (scan.inFlight && now - scan.startedAt > kScopeInFlightMaxSec) scan.inFlight = false; // lost
|
||||
if (scan.inFlight && scan.phase == ScopePhase::Loading) return; // still loading for the last session
|
||||
++scan.gen;
|
||||
scan.phase = ScopePhase::Idle;
|
||||
scan.failures = 0;
|
||||
scan.autoRetry = false;
|
||||
scan.retryAt = 0.0;
|
||||
scan.error.clear();
|
||||
}
|
||||
|
||||
void scopeScanInvalidate(ScopeScan& scan)
|
||||
{
|
||||
++scan.gen;
|
||||
scan.phase = ScopePhase::Idle;
|
||||
scan.failures = 0;
|
||||
scan.autoRetry = false;
|
||||
scan.retryAt = 0.0;
|
||||
scan.error.clear();
|
||||
}
|
||||
|
||||
void scopeScanRetry(ScopeScan& scan)
|
||||
{
|
||||
if (scan.phase != ScopePhase::Failed) return;
|
||||
scan.phase = ScopePhase::Idle;
|
||||
scan.failures = 0;
|
||||
scan.autoRetry = false;
|
||||
scan.retryAt = 0.0;
|
||||
scan.error.clear();
|
||||
}
|
||||
|
||||
double scopeRetryDelaySec(int failures)
|
||||
{
|
||||
if (failures <= 1) return 10.0;
|
||||
if (failures == 2) return 30.0;
|
||||
return 60.0;
|
||||
}
|
||||
|
||||
bool scopeFailureRetries(rpc::RpcFailureKind kind, const std::string& message)
|
||||
{
|
||||
using K = rpc::RpcFailureKind;
|
||||
switch (kind) {
|
||||
case K::NotListening:
|
||||
case K::ConnectTimeout:
|
||||
case K::Warmup:
|
||||
case K::Deferred:
|
||||
case K::ShuttingDown:
|
||||
case K::Unhandled:
|
||||
case K::Aborted:
|
||||
return true;
|
||||
case K::Other: {
|
||||
std::string lower = message;
|
||||
std::transform(lower.begin(), lower.end(), lower.begin(),
|
||||
[](unsigned char c) { return static_cast<char>(std::tolower(c)); });
|
||||
return lower.find("not connected") != std::string::npos;
|
||||
}
|
||||
default:
|
||||
return false; // ReplyTimeout, QueueFull, AppError, Auth, parse/type errors
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace services
|
||||
} // namespace dragonx
|
||||
|
||||
@@ -10,8 +10,12 @@
|
||||
// Shielded only: a transparent address can't receive a non-coinbase output on DragonX (private chain).
|
||||
// Pure apart from the merge call it is handed, so the test target can drive it.
|
||||
|
||||
#include "rpc/rpc_failure.h"
|
||||
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
#include <chrono>
|
||||
#include <cstdint>
|
||||
#include <functional>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
@@ -26,10 +30,14 @@ struct NoteGroup {
|
||||
double amount = 0.0;
|
||||
};
|
||||
|
||||
// Spendable shielded notes grouped by address, most notes first. Transparent UTXOs and unconfirmed or
|
||||
// watch-only notes are left out (z_mergetoaddress only spends confirmed notes it has keys for).
|
||||
// Spendable shielded notes grouped by address, most notes first. Transparent UTXOs and unconfirmed,
|
||||
// watch-only or locked notes are left out (z_mergetoaddress only spends confirmed, unlocked notes it has
|
||||
// keys for).
|
||||
std::vector<NoteGroup> groupSpendableNotes(const nlohmann::json& zListUnspent);
|
||||
|
||||
// A z_listunspent entry the wallet has locked, e.g. for an operation in flight ("locked": true).
|
||||
bool noteIsLocked(const nlohmann::json& zListUnspentEntry);
|
||||
|
||||
// Worth consolidating in place: at least two notes, and more than one batch's fee to work with.
|
||||
bool worthConsolidating(const NoteGroup& group, double fee);
|
||||
|
||||
@@ -59,5 +67,59 @@ struct AddressRun {
|
||||
// locks a batch's notes before the call returns, so each call takes the next batch. At most maxBatches.
|
||||
AddressRun consolidateInPlace(const std::string& address, const MergeCall& call, int maxBatches = 20);
|
||||
|
||||
// ── Scope scan (the Merge/Consolidate dialog's listunspent + z_listunspent) ─────────────────────────
|
||||
// Both calls are whole-wallet scans under the daemon's cs_main. The dialog used to post the pair again on
|
||||
// the frame after any failure, every frame for as long as it stayed open (and forever on Lite, which has
|
||||
// no node). This decides when a scan may be posted; the dialog owns one ScopeScan.
|
||||
|
||||
inline double steadySeconds() // ImGui::GetTime() stands still while the window is minimized
|
||||
{
|
||||
return std::chrono::duration<double>(std::chrono::steady_clock::now().time_since_epoch()).count();
|
||||
}
|
||||
|
||||
inline constexpr long kScopeCallTimeoutSec = 120; // each call; a large wallet can take minutes
|
||||
inline constexpr double kScopeInFlightMaxSec = 1800; // a scan outstanding this long is presumed lost
|
||||
inline constexpr int kScopeMaxAutoRetries = 3;
|
||||
|
||||
enum class ScopePhase { Idle, Loading, Loaded, Failed };
|
||||
|
||||
struct ScopeScan {
|
||||
ScopePhase phase = ScopePhase::Idle;
|
||||
std::uint32_t gen = 0; // bumped per dialog session; a result from another session is dropped
|
||||
bool inFlight = false; // a scan is posted and its result not yet in (survives close/reopen)
|
||||
std::uint32_t inFlightGen = 0; // the session that posted it: only its result clears inFlight
|
||||
double startedAt = 0.0;
|
||||
int failures = 0;
|
||||
bool autoRetry = false; // the last failure was "node not ready yet": retry by itself
|
||||
double retryAt = 0.0;
|
||||
std::string error;
|
||||
};
|
||||
|
||||
struct ScopeInputs {
|
||||
bool mergeMode = false;
|
||||
bool busyWithOp = false; // a merge was submitted or is in flight
|
||||
bool nodeReady = false; // App::walletScanReady()
|
||||
double now = 0.0;
|
||||
};
|
||||
|
||||
enum class ScopeWant { Nothing, Post, WaitNode, WaitBackoff };
|
||||
|
||||
ScopeWant scopeScanWant(const ScopeScan& scan, const ScopeInputs& in);
|
||||
// Mark a scan posted: Loading, in flight for this session. Returns the generation to finish it with.
|
||||
std::uint32_t scopeScanBegin(ScopeScan& scan, double now);
|
||||
// Record a scan's result. True when it belongs to the current session and succeeded: apply its data.
|
||||
bool scopeScanFinish(ScopeScan& scan, std::uint32_t gen, const std::string& error, rpc::RpcFailureKind kind,
|
||||
double now);
|
||||
// The dialog opened: start a new session, unless a scan of the last one is still loading (adopt it).
|
||||
void scopeScanOpen(ScopeScan& scan, double now);
|
||||
// The data went stale (reconnect): the next want is a fresh scan. An in-flight scan stays guarded.
|
||||
void scopeScanInvalidate(ScopeScan& scan);
|
||||
// The user pressed Retry after a failure.
|
||||
void scopeScanRetry(ScopeScan& scan);
|
||||
double scopeRetryDelaySec(int failures); // 10, 30, then 60 s
|
||||
// Retry by itself only when the node wasn't ready (refused, warming up, held back as busy, aborted):
|
||||
// not after a reply timeout or a real error, each of which would cost another pair of full scans.
|
||||
bool scopeFailureRetries(rpc::RpcFailureKind kind, const std::string& message);
|
||||
|
||||
} // namespace services
|
||||
} // namespace dragonx
|
||||
|
||||
@@ -1293,12 +1293,15 @@ void RenderSettingsPage(App* app) {
|
||||
if (BTN("##wreq", TR("settings_request_payment"), ICON_MD_QR_CODE))
|
||||
RequestPaymentDialog::show();
|
||||
if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_request_payment"));
|
||||
if (BTN("##wshield", TR("settings_shield_mining"), ICON_MD_SHIELD))
|
||||
ShieldDialog::show(ShieldDialog::Mode::ShieldCoinbase);
|
||||
if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_shield_mining"));
|
||||
if (BTN("##wmerge", TR("settings_merge_to_address"), ICON_MD_CALL_MERGE))
|
||||
ShieldDialog::showMerge();
|
||||
if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_merge"));
|
||||
// z_shieldcoinbase / z_mergetoaddress are full-node RPCs: Lite has no node to send them to.
|
||||
if (app->supportsFullNodeLifecycleActions()) {
|
||||
if (BTN("##wshield", TR("settings_shield_mining"), ICON_MD_SHIELD))
|
||||
ShieldDialog::show(ShieldDialog::Mode::ShieldCoinbase);
|
||||
if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_shield_mining"));
|
||||
if (BTN("##wmerge", TR("settings_merge_to_address"), ICON_MD_CALL_MERGE))
|
||||
ShieldDialog::showMerge();
|
||||
if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_merge"));
|
||||
}
|
||||
if (BTN("##wclear", TR("settings_clear_ztx"), ICON_MD_DELETE_SWEEP))
|
||||
s_settingsState.confirm_clear_ztx = true;
|
||||
if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("tt_clear_ztx"));
|
||||
|
||||
@@ -16,7 +16,9 @@
|
||||
#include "imgui.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <set>
|
||||
#include <stdexcept>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <cstdio>
|
||||
@@ -41,9 +43,8 @@ static bool s_op_terminal = false; // async op reached success/fa
|
||||
static std::string s_operation_id;
|
||||
static std::string s_status_message;
|
||||
static double s_last_poll = 0.0; // live-progress self-poll timer (ImGui::GetTime seconds)
|
||||
// Scope of what can be consolidated (fetched once on open, merge mode only).
|
||||
static bool s_scope_loading = false;
|
||||
static bool s_scope_loaded = false;
|
||||
// Scope of what can be consolidated (merge mode only). services::ScopeScan decides when to scan.
|
||||
static services::ScopeScan s_scan;
|
||||
static int s_t_count = 0, s_z_count = 0;
|
||||
static double s_t_amount = 0.0, s_z_amount = 0.0;
|
||||
static bool s_creating_addr = false; // z_getnewaddress in flight (empty state)
|
||||
@@ -52,16 +53,22 @@ static bool s_creating_addr = false; // z_getnewaddress in flight (
|
||||
static bool s_per_address = false;
|
||||
static std::vector<services::NoteGroup> s_groups; // spendable shielded notes by address (scope load)
|
||||
static std::set<std::string> s_selected; // addresses ticked for per-address consolidation
|
||||
static std::set<std::string> s_unticked; // unticked by the user this opening: kept across a re-scan
|
||||
struct PerAddressRun {
|
||||
services::AddressRun run;
|
||||
std::vector<int> state; // per opid: 0 = running, 1 = done, 2 = failed
|
||||
std::vector<int> state; // per opid: 0 = running, 1 = done, 2 = failed, 3 = gone from the daemon (unknown)
|
||||
std::string failure; // first failed op's message
|
||||
};
|
||||
static std::vector<PerAddressRun> s_runs; // after submit
|
||||
static bool s_runs_submitting = false;
|
||||
// The op-status polls: one in flight at a time, cleared only by its reply, even across a close and
|
||||
// reopen; a reply for an earlier opening (another session) changes nothing else.
|
||||
static bool s_poll_in_flight = false;
|
||||
static unsigned s_poll_session = 0;
|
||||
|
||||
static void resetTransient()
|
||||
{
|
||||
++s_poll_session;
|
||||
s_operation_pending = false;
|
||||
s_op_terminal = false;
|
||||
s_confirm = false;
|
||||
@@ -73,33 +80,47 @@ static void resetTransient()
|
||||
}
|
||||
|
||||
// Count + sum spendable transparent UTXOs and shielded notes so the user can see the scope of a
|
||||
// consolidation (and how many batches it may take). Read-only; runs off the UI thread.
|
||||
// consolidation (and how many batches it may take). Read-only; runs off the UI thread. Only when
|
||||
// services::scopeScanWant() says so: both calls are whole-wallet scans under the daemon's cs_main.
|
||||
static void loadScope(App* app)
|
||||
{
|
||||
if (!app || !app->worker()) return;
|
||||
s_scope_loading = true; s_scope_loaded = false;
|
||||
app->worker()->post([app, rpc = app->rpc()]() -> rpc::RPCWorker::MainCb {
|
||||
const std::uint32_t gen = services::scopeScanBegin(s_scan, services::steadySeconds());
|
||||
app->worker()->post([app, rpc = app->rpc(), gen]() -> rpc::RPCWorker::MainCb {
|
||||
int tC = 0, zC = 0; double tA = 0.0, zA = 0.0; std::string error;
|
||||
rpc::RpcFailureKind kind = rpc::RpcFailureKind::None;
|
||||
std::vector<services::NoteGroup> groups;
|
||||
try {
|
||||
if (!rpc) throw std::runtime_error("Not connected");
|
||||
// On a large wallet each scan can outlast the default 30 s; give them 120 s, counted as
|
||||
// maintenance calls so a disconnect aborts them rather than waiting.
|
||||
App::MaintenanceCallScope maint(*app);
|
||||
rpc::RPCClient::TraceScope trace("Shield dialog / Scope count");
|
||||
nlohmann::json us = rpc->call("listunspent", nlohmann::json::array({0}));
|
||||
nlohmann::json us = rpc->call("listunspent", nlohmann::json::array({0}), services::kScopeCallTimeoutSec);
|
||||
if (us.is_array()) for (const auto& u : us) {
|
||||
if (u.value("confirmations", 0) >= 1 && u.value("spendable", true)) { ++tC; tA += u.value("amount", 0.0); }
|
||||
}
|
||||
nlohmann::json zs = rpc->call("z_listunspent", nlohmann::json::array({0}));
|
||||
nlohmann::json zs = rpc->call("z_listunspent", nlohmann::json::array({0}), services::kScopeCallTimeoutSec);
|
||||
if (zs.is_array()) for (const auto& z : zs) {
|
||||
if (z.value("confirmations", 0) >= 1) { ++zC; zA += z.value("amount", 0.0); }
|
||||
if (z.value("confirmations", 0) >= 1 && !services::noteIsLocked(z)) { ++zC; zA += z.value("amount", 0.0); }
|
||||
}
|
||||
groups = services::groupSpendableNotes(zs);
|
||||
} catch (const std::exception& e) { error = e.what(); }
|
||||
return [tC, zC, tA, zA, error, groups]() {
|
||||
s_scope_loading = false; s_scope_loaded = error.empty();
|
||||
} catch (const std::exception& e) {
|
||||
error = e.what();
|
||||
kind = rpc::rpcFailureKindOf(e);
|
||||
if (error.empty()) error = "error";
|
||||
} catch (...) {
|
||||
error = "unknown error";
|
||||
kind = rpc::RpcFailureKind::Other;
|
||||
}
|
||||
return [tC, zC, tA, zA, error, kind, gen, groups]() {
|
||||
if (!services::scopeScanFinish(s_scan, gen, error, kind, services::steadySeconds())) return;
|
||||
s_t_count = tC; s_z_count = zC; s_t_amount = tA; s_z_amount = zA;
|
||||
s_groups = groups;
|
||||
s_selected.clear(); // every address worth it, ticked by default
|
||||
s_selected.clear(); // every address worth it, ticked by default, except ones the user unticked
|
||||
for (const auto& g : s_groups)
|
||||
if (services::worthConsolidating(g, s_fee)) s_selected.insert(g.address);
|
||||
if (services::worthConsolidating(g, s_fee) && !s_unticked.count(g.address))
|
||||
s_selected.insert(g.address);
|
||||
// Clamp the source to what actually has inputs (unless the user is mid-op).
|
||||
const bool tOk = tC > 0, zOk = zC > 0;
|
||||
if (!s_operation_pending) {
|
||||
@@ -128,12 +149,13 @@ void ShieldDialog::show(Mode mode)
|
||||
s_utxo_limit = (int)schema::UI().drawElement("business", "utxo-limit").size;
|
||||
if (s_utxo_limit < 1) s_utxo_limit = 50;
|
||||
s_advanced = false;
|
||||
s_scope_loaded = false; s_scope_loading = false;
|
||||
services::scopeScanOpen(s_scan, services::steadySeconds());
|
||||
s_t_count = s_z_count = 0; s_t_amount = s_z_amount = 0.0;
|
||||
s_last_poll = 0.0;
|
||||
s_per_address = false;
|
||||
s_groups.clear();
|
||||
s_selected.clear();
|
||||
s_unticked.clear();
|
||||
}
|
||||
|
||||
void ShieldDialog::showShieldCoinbase(const std::string& fromAddress)
|
||||
@@ -163,6 +185,15 @@ void ShieldDialog::hide()
|
||||
resetTransient();
|
||||
}
|
||||
|
||||
void ShieldDialog::invalidateScope()
|
||||
{
|
||||
s_confirm = false; // what the user was confirming was read on the old connection
|
||||
services::scopeScanInvalidate(s_scan);
|
||||
s_t_count = s_z_count = 0; s_t_amount = s_z_amount = 0.0;
|
||||
s_groups.clear();
|
||||
s_selected.clear();
|
||||
}
|
||||
|
||||
// Relevant count/amount for the currently-selected merge source.
|
||||
static int srcCount() { return s_src == 0 ? s_t_count : s_src == 1 ? s_z_count : (s_t_count + s_z_count); }
|
||||
static double srcAmount() { return s_src == 0 ? s_t_amount : s_src == 1 ? s_z_amount : (s_t_amount + s_z_amount); }
|
||||
@@ -241,17 +272,34 @@ static void submitOperation(App* app)
|
||||
nlohmann::json addrs = nlohmann::json::array();
|
||||
for (const auto& a : fromAddrs) addrs.push_back(a);
|
||||
nlohmann::json result; std::string error;
|
||||
bool uncertain = false;
|
||||
try {
|
||||
if (!rpc) throw std::runtime_error("Not connected");
|
||||
// The daemon scans the whole wallet before it returns the opid; on a large wallet that can
|
||||
// outlast 30 s, which reported a failure for a merge that had started. 120 s, as a maintenance
|
||||
// call so a disconnect aborts it instead of waiting.
|
||||
App::MaintenanceCallScope maint(*app);
|
||||
rpc::RPCClient::TraceScope trace("Shield dialog / Consolidate");
|
||||
// fromaddrs, toaddr, fee, transparent_limit, shielded_limit — cap both to the batch size.
|
||||
result = rpc->call("z_mergetoaddress", {addrs, to, fee, limit, limit});
|
||||
} catch (const std::exception& e) { error = e.what(); }
|
||||
return [app, result, error]() {
|
||||
result = rpc->call("z_mergetoaddress", {addrs, to, fee, limit, limit}, services::kScopeCallTimeoutSec);
|
||||
} catch (const std::exception& e) {
|
||||
error = e.what();
|
||||
// Sent, then cut off with no reply: our own abort on a lifecycle disconnect, the reply timeout
|
||||
// or a dropped connection. The daemon keeps running the handler and may still queue the merge.
|
||||
if (const auto* t = dynamic_cast<const rpc::RpcTransportError*>(&e))
|
||||
uncertain = t->requestSent && t->httpStatus == 0;
|
||||
}
|
||||
return [app, result, error, uncertain]() {
|
||||
if (error.empty()) {
|
||||
s_operation_id = result.value("opid", "");
|
||||
s_status_message = TR("merge_progress");
|
||||
Notifications::instance().success(TR("merge_started"));
|
||||
app->trackOperation(s_operation_id);
|
||||
} else if (uncertain) {
|
||||
s_operation_pending = false; s_op_terminal = true;
|
||||
s_confirm = false; // don't leave Confirm armed for a merge that may still be running
|
||||
s_status_message = TR("merge_submit_uncertain");
|
||||
Notifications::instance().warning(TR("merge_submit_uncertain"));
|
||||
} else {
|
||||
s_operation_pending = false; s_op_terminal = true;
|
||||
s_status_message = std::string(TR("shield_error_prefix")) + error;
|
||||
@@ -325,86 +373,142 @@ static void submitPerAddress(App* app)
|
||||
});
|
||||
}
|
||||
|
||||
// Progress of a per-address run: poll every ~2s until each batch's operation is done or failed. Unfiltered,
|
||||
// like the shared poller (some daemons reject the per-opid form); only our operations are read.
|
||||
// Progress of a per-address run: poll every ~2s until each batch's operation is done or failed. Filtered
|
||||
// to the batches still running, as the shared poller does (unfiltered if the daemon rejected the filter).
|
||||
static void pollPerAddress(App* app)
|
||||
{
|
||||
if (s_runs.empty() || s_op_terminal || !app->worker()) return;
|
||||
if (s_runs.empty() || s_op_terminal || s_poll_in_flight || !app->worker()) return;
|
||||
const double now = ImGui::GetTime();
|
||||
if (now - s_last_poll < 2.0) return;
|
||||
std::vector<std::string> running;
|
||||
for (const auto& r : s_runs)
|
||||
for (size_t i = 0; i < r.run.opids.size(); ++i)
|
||||
if (r.state[i] == 0) running.push_back(r.run.opids[i]);
|
||||
const auto filter = services::NetworkRefreshService::buildOperationFilterParams(running);
|
||||
if (!filter) return;
|
||||
s_last_poll = now;
|
||||
app->worker()->post([rpc = app->rpc()]() -> rpc::RPCWorker::MainCb {
|
||||
s_poll_in_flight = true;
|
||||
const unsigned session = s_poll_session;
|
||||
nlohmann::json params = app->opidFilterUnsupported() ? nlohmann::json::array() : *filter;
|
||||
app->worker()->post([rpc = app->rpc(), params = std::move(params), session]() -> rpc::RPCWorker::MainCb {
|
||||
nlohmann::json result; std::string error;
|
||||
try {
|
||||
if (!rpc) throw std::runtime_error("Not connected");
|
||||
rpc::RPCClient::TraceScope trace("Shield dialog / Consolidate in place status");
|
||||
result = rpc->call("z_getoperationstatus", nlohmann::json::array());
|
||||
result = rpc->call("z_getoperationstatus", params);
|
||||
} catch (const std::exception& e) { error = e.what(); }
|
||||
return [result, error]() {
|
||||
return [result, error, session]() {
|
||||
s_poll_in_flight = false;
|
||||
if (session != s_poll_session) return; // a reply for an earlier opening
|
||||
if (!error.empty() || !result.is_array()) return; // transient — retry next tick
|
||||
std::set<std::string> reported;
|
||||
for (const auto& op : result) {
|
||||
if (!op.is_object() || !op.contains("id") || !op["id"].is_string()) continue;
|
||||
const std::string id = op["id"].get<std::string>();
|
||||
reported.insert(id);
|
||||
const std::string status = (op.contains("status") && op["status"].is_string())
|
||||
? op["status"].get<std::string>() : std::string();
|
||||
for (auto& r : s_runs) {
|
||||
for (size_t i = 0; i < r.run.opids.size(); ++i) {
|
||||
if (r.run.opids[i] != id || r.state[i] != 0) continue;
|
||||
if (status == "success") r.state[i] = 1;
|
||||
else if (status == "failed" || status == "cancelled") {
|
||||
else if (status == "failed" || status == "cancelled" || status == "canceled") {
|
||||
r.state[i] = 2;
|
||||
if (r.failure.empty() && op.contains("error") && op["error"].is_object())
|
||||
r.failure = op["error"].value("message", std::string());
|
||||
if (r.failure.empty() && op.contains("error") && op["error"].is_object() &&
|
||||
op["error"].contains("message") && op["error"]["message"].is_string())
|
||||
r.failure = op["error"]["message"].get<std::string>();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// A valid reply without one of our running ops: the daemon no longer holds it (restart, or
|
||||
// popped by z_getoperationresult); its outcome can't be confirmed. One poll at a time, and
|
||||
// states change only here, so the running set now is the set that was asked for.
|
||||
for (auto& r : s_runs)
|
||||
for (size_t i = 0; i < r.run.opids.size(); ++i)
|
||||
if (r.state[i] == 0 && !reported.count(r.run.opids[i])) r.state[i] = 3;
|
||||
bool allDone = true;
|
||||
int failed = 0;
|
||||
int failed = 0, unknown = 0;
|
||||
for (const auto& r : s_runs)
|
||||
for (int st : r.state) { if (st == 0) allDone = false; if (st == 2) ++failed; }
|
||||
for (int st : r.state) { if (st == 0) allDone = false; if (st == 2) ++failed; if (st == 3) ++unknown; }
|
||||
if (!allDone) return;
|
||||
s_operation_pending = false;
|
||||
s_op_terminal = true;
|
||||
if (failed == 0) {
|
||||
s_status_message = TR("shield_completed");
|
||||
Notifications::instance().success(TR("shield_merge_done"));
|
||||
} else {
|
||||
if (failed > 0) {
|
||||
s_status_message = TR("merge_keep_each_some_failed");
|
||||
Notifications::instance().error(TR("merge_keep_each_some_failed"));
|
||||
} else if (unknown > 0) {
|
||||
s_status_message = TR("send_status_unconfirmed");
|
||||
Notifications::instance().warning(TR("send_status_unconfirmed"));
|
||||
} else {
|
||||
s_status_message = TR("shield_completed");
|
||||
Notifications::instance().success(TR("shield_merge_done"));
|
||||
}
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
// Live-progress self-poll: while an op is in flight, poll z_getoperationstatus every ~2s so the modal
|
||||
// shows "Consolidating… → Done/Failed" without a manual button. (The shared poller also tracks it for
|
||||
// balance refresh; this drives only the inline display.)
|
||||
// shows "Consolidating… → Done/Failed" without a manual button. (The shared poller also tracks it: it
|
||||
// refreshes balances and raises the failure toast; this drives the inline display and the success toast.)
|
||||
static void pollOperation(App* app)
|
||||
{
|
||||
if (s_operation_id.empty() || s_op_terminal || !app->worker()) return;
|
||||
if (s_operation_id.empty() || s_op_terminal || s_poll_in_flight || !app->worker()) return;
|
||||
const double now = ImGui::GetTime();
|
||||
if (now - s_last_poll < 2.0) return;
|
||||
const std::string opid = s_operation_id;
|
||||
// [[opid]]: the argument is an ARRAY of ids. The old {json::array({opid})} collapsed to ["opid"]
|
||||
// (C++17 brace init of a json from one json copies it), which the daemon rejects, so this poll failed
|
||||
// every time and the dialog never saw its op finish.
|
||||
const auto filter = services::NetworkRefreshService::buildOperationFilterParams({opid});
|
||||
if (!filter) return;
|
||||
s_last_poll = now;
|
||||
std::string opid = s_operation_id;
|
||||
app->worker()->post([rpc = app->rpc(), opid]() -> rpc::RPCWorker::MainCb {
|
||||
s_poll_in_flight = true;
|
||||
const unsigned session = s_poll_session;
|
||||
nlohmann::json params = app->opidFilterUnsupported() ? nlohmann::json::array() : *filter;
|
||||
app->worker()->post([rpc = app->rpc(), params = std::move(params), opid, session]() -> rpc::RPCWorker::MainCb {
|
||||
nlohmann::json result; std::string error;
|
||||
try {
|
||||
if (!rpc) throw std::runtime_error("Not connected");
|
||||
rpc::RPCClient::TraceScope trace("Shield dialog / Op status");
|
||||
result = rpc->call("z_getoperationstatus", {nlohmann::json::array({opid})});
|
||||
result = rpc->call("z_getoperationstatus", params);
|
||||
} catch (const std::exception& e) { error = e.what(); }
|
||||
return [result, error]() {
|
||||
if (!error.empty() || !result.is_array() || result.empty()) return; // transient — retry next tick
|
||||
const auto& op = result[0];
|
||||
const std::string status = op.value("status", "");
|
||||
return [result, error, opid, session]() {
|
||||
s_poll_in_flight = false;
|
||||
if (session != s_poll_session || opid != s_operation_id) return; // the dialog moved on
|
||||
if (!error.empty() || !result.is_array()) return; // transient — retry next tick
|
||||
const nlohmann::json* found = nullptr;
|
||||
for (const auto& o : result) {
|
||||
if (o.is_object() && o.contains("id") && o["id"].is_string() && o["id"].get<std::string>() == opid) {
|
||||
found = &o;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
// A valid reply without our op: the daemon no longer holds it (it restarted, or another
|
||||
// client popped it with z_getoperationresult). It registers an op before returning its id,
|
||||
// so this is no race. The outcome can't be confirmed; stop polling.
|
||||
s_operation_pending = false; s_op_terminal = true;
|
||||
s_status_message = TR("send_status_unconfirmed");
|
||||
Notifications::instance().warning(TR("send_status_unconfirmed"));
|
||||
return;
|
||||
}
|
||||
const nlohmann::json& op = *found;
|
||||
const std::string status = (op.contains("status") && op["status"].is_string())
|
||||
? op["status"].get<std::string>() : std::string();
|
||||
if (status == "success") {
|
||||
s_operation_pending = false; s_op_terminal = true;
|
||||
s_status_message = TR("shield_completed");
|
||||
Notifications::instance().success(TR("shield_merge_done"));
|
||||
} else if (status == "failed") {
|
||||
std::string msg = op.value("error", nlohmann::json{}).value("message", std::string(TR("shield_unknown_error")));
|
||||
} else if (status == "failed" || status == "cancelled" || status == "canceled") {
|
||||
std::string msg = TR("shield_unknown_error");
|
||||
if (op.contains("error") && op["error"].is_object() && op["error"].contains("message") &&
|
||||
op["error"]["message"].is_string())
|
||||
msg = op["error"]["message"].get<std::string>();
|
||||
s_operation_pending = false; s_op_terminal = true;
|
||||
s_status_message = std::string(TR("shield_op_failed")) + msg;
|
||||
Notifications::instance().error(std::string(TR("shield_op_failed")) + msg);
|
||||
// No toast: the op is tracked (App::trackOperation) and the shared opid poller raises the
|
||||
// one failure toast, whether this dialog is open or not.
|
||||
}
|
||||
// queued / executing → leave the "Consolidating…" message and keep polling.
|
||||
};
|
||||
@@ -426,6 +530,9 @@ void ShieldDialog::render(App* app)
|
||||
auto cancelBtn = S.button("dialogs.shield", "cancel-button");
|
||||
const float dp = Layout::dpiScale();
|
||||
const bool isMerge = (s_mode == Mode::MergeToAddress);
|
||||
// Merging needs the full node's z_mergetoaddress. Lite has no node: its scope scan used to fail and be
|
||||
// re-posted every frame for as long as the dialog stayed open. (Shield coinbase keeps its own gating.)
|
||||
if (isMerge && !app->supportsFullNodeLifecycleActions()) { s_open = false; return; }
|
||||
|
||||
const char* title = s_consolidate ? TR("consolidate_title")
|
||||
: isMerge ? TR("merge_title")
|
||||
@@ -441,7 +548,14 @@ void ShieldDialog::render(App* app)
|
||||
autoSelectDestination(state);
|
||||
pollOperation(app);
|
||||
pollPerAddress(app);
|
||||
if (isMerge && !s_scope_loaded && !s_scope_loading && s_operation_id.empty()) loadScope(app);
|
||||
if (isMerge) {
|
||||
services::ScopeInputs in;
|
||||
in.mergeMode = true;
|
||||
in.busyWithOp = !s_operation_id.empty() || s_operation_pending || !s_runs.empty();
|
||||
in.nodeReady = app->walletScanReady();
|
||||
in.now = services::steadySeconds();
|
||||
if (services::scopeScanWant(s_scan, in) == services::ScopeWant::Post) loadScope(app);
|
||||
}
|
||||
|
||||
// ── Description ──────────────────────────────────────────────────────────────────────────────
|
||||
ImGui::TextWrapped("%s", s_consolidate ? TR("consolidate_desc")
|
||||
@@ -455,14 +569,24 @@ void ShieldDialog::render(App* app)
|
||||
|
||||
// ── Merge: scope + source selector ──────────────────────────────────────────────────────────
|
||||
if (isMerge && !opInFlight) {
|
||||
if (s_scope_loading) {
|
||||
if (s_scan.phase == services::ScopePhase::Loading) {
|
||||
material::Type().textColored(material::TypeStyle::Caption, material::OnSurfaceMedium(),
|
||||
TR("merge_scope_loading"));
|
||||
} else if (s_scope_loaded) {
|
||||
} else if (s_scan.phase == services::ScopePhase::Loaded) {
|
||||
char buf[160];
|
||||
std::snprintf(buf, sizeof(buf), TR("merge_scope_fmt"),
|
||||
s_t_count, s_z_count, fmtAmt(s_t_amount + s_z_amount).c_str());
|
||||
material::Type().textColored(material::TypeStyle::Caption, material::OnSurfaceMedium(), buf);
|
||||
} else if (s_scan.phase == services::ScopePhase::Failed) {
|
||||
const std::string reason = s_scan.error.size() > 160 ? s_scan.error.substr(0, 160) + "..." : s_scan.error;
|
||||
char buf[320];
|
||||
std::snprintf(buf, sizeof(buf), TR("merge_scope_failed_fmt"), reason.c_str());
|
||||
wrappedCaption(material::Warning(), buf);
|
||||
if (material::TactileButton(TR("retry"), ImVec2(0, 0), S.resolveFont(cancelBtn.font)))
|
||||
services::scopeScanRetry(s_scan);
|
||||
} else {
|
||||
material::Type().textColored(material::TypeStyle::Caption, material::OnSurfaceMedium(),
|
||||
state.isLocked() ? TR("merge_wait_locked") : TR("merge_waiting_node"));
|
||||
}
|
||||
ImGui::Spacing();
|
||||
|
||||
@@ -493,7 +617,7 @@ void ShieldDialog::render(App* app)
|
||||
ImGui::Spacing();
|
||||
int listed = 0;
|
||||
for (const auto& g : s_groups) if (g.notes >= 2) ++listed;
|
||||
if (s_scope_loaded && listed == 0) {
|
||||
if (s_scan.phase == services::ScopePhase::Loaded && listed == 0) {
|
||||
wrappedCaption(material::Warning(), TR("merge_keep_each_none"));
|
||||
} else if (listed > 0) {
|
||||
const float rowH = ImGui::GetFrameHeightWithSpacing();
|
||||
@@ -511,8 +635,8 @@ void ShieldDialog::render(App* app)
|
||||
ImGui::PushID(g.address.c_str());
|
||||
ImGui::BeginDisabled(!worth);
|
||||
if (ImGui::Checkbox(row, &ticked)) {
|
||||
if (ticked) s_selected.insert(g.address);
|
||||
else s_selected.erase(g.address);
|
||||
if (ticked) { s_selected.insert(g.address); s_unticked.erase(g.address); }
|
||||
else { s_selected.erase(g.address); s_unticked.insert(g.address); }
|
||||
}
|
||||
ImGui::EndDisabled();
|
||||
if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled))
|
||||
@@ -618,7 +742,7 @@ void ShieldDialog::render(App* app)
|
||||
ImGui::Spacing();
|
||||
wrappedCaption(material::Warning(), hb);
|
||||
}
|
||||
} else if (isMerge && s_scope_loaded && srcCount() > s_utxo_limit) {
|
||||
} else if (isMerge && s_scan.phase == services::ScopePhase::Loaded && srcCount() > s_utxo_limit) {
|
||||
char hb[160];
|
||||
std::snprintf(hb, sizeof(hb), TR("merge_batch_fmt"), s_utxo_limit);
|
||||
ImGui::Spacing();
|
||||
@@ -634,8 +758,8 @@ void ShieldDialog::render(App* app)
|
||||
const std::string label = app->getAddressLabel(r.run.address);
|
||||
const char* name = label.empty() ? nullptr : label.c_str();
|
||||
const std::string shortA = shortAddr(r.run.address);
|
||||
int done = 0, failed = 0;
|
||||
for (int st : r.state) { if (st == 1) ++done; if (st == 2) ++failed; }
|
||||
int done = 0, failed = 0, unknown = 0;
|
||||
for (int st : r.state) { if (st == 1) ++done; if (st == 2) ++failed; if (st == 3) ++unknown; }
|
||||
const int batches = static_cast<int>(r.run.opids.size());
|
||||
char line[320];
|
||||
ImU32 col = material::OnSurfaceMedium();
|
||||
@@ -647,6 +771,9 @@ void ShieldDialog::render(App* app)
|
||||
std::snprintf(line, sizeof(line), TR("merge_keep_each_status_failed"), name ? name : shortA.c_str(),
|
||||
r.failure.c_str());
|
||||
col = material::Error();
|
||||
} else if (unknown > 0 && done + unknown == batches) {
|
||||
std::snprintf(line, sizeof(line), TR("merge_keep_each_status_unconfirmed"), name ? name : shortA.c_str());
|
||||
col = material::Warning();
|
||||
} else if (done == batches) {
|
||||
std::snprintf(line, sizeof(line), TR("merge_keep_each_status_done"), name ? name : shortA.c_str(),
|
||||
r.run.notesMerged, batches);
|
||||
@@ -717,8 +844,9 @@ void ShieldDialog::render(App* app)
|
||||
}
|
||||
|
||||
bool can_submit = haveDest && connected && !syncing;
|
||||
if (isMerge && s_scope_loaded && srcCount() == 0) can_submit = false;
|
||||
if (perAddress) can_submit = connected && !syncing && s_scope_loaded && !selectedGroups().empty();
|
||||
const bool scopeLoaded = s_scan.phase == services::ScopePhase::Loaded;
|
||||
if (isMerge && scopeLoaded && srcCount() == 0) can_submit = false;
|
||||
if (perAddress) can_submit = connected && !syncing && scopeLoaded && !selectedGroups().empty();
|
||||
|
||||
float footerBtnW = shieldBtn.width + cancelBtn.width + ImGui::GetStyle().ItemSpacing.x;
|
||||
material::BeginOverlayDialogFooter(footerBtnW, /*drawSeparator=*/false);
|
||||
|
||||
@@ -52,6 +52,12 @@ public:
|
||||
* @brief Close the dialog (used by the UI sweep teardown)
|
||||
*/
|
||||
static void hide();
|
||||
|
||||
/**
|
||||
* @brief Forget the scope (inputs) read for the Merge/Consolidate view: the node connection changed,
|
||||
* so it may be a different wallet. The next render reads it again once the node is ready.
|
||||
*/
|
||||
static void invalidateScope();
|
||||
};
|
||||
|
||||
} // namespace ui
|
||||
|
||||
@@ -2493,6 +2493,7 @@ void I18n::loadBuiltinEnglish()
|
||||
strings_["shield_unknown_error"] = "Unknown error";
|
||||
strings_["shield_send_failed"] = "Shield failed: ";
|
||||
strings_["merge_send_failed"] = "Merge failed: ";
|
||||
strings_["merge_submit_uncertain"] = "The node didn't confirm the merge before the connection was interrupted. It may still go through \xE2\x80\x94 check History after reconnecting before merging again.";
|
||||
strings_["merge_description"] = "Merge multiple UTXOs into a single shielded address. This can help reduce wallet size and improve privacy.";
|
||||
strings_["merge_funds"] = "Merge Funds";
|
||||
strings_["merge_started"] = "Merge operation started";
|
||||
@@ -2503,6 +2504,9 @@ void I18n::loadBuiltinEnglish()
|
||||
strings_["consolidate_funds_btn"] = "Consolidate";
|
||||
strings_["merge_scope_loading"] = "Checking your inputs\xE2\x80\xA6";
|
||||
strings_["merge_scope_fmt"] = "%d transparent + %d shielded inputs \xC2\xB7 ~%s DRGX spendable";
|
||||
strings_["merge_waiting_node"] = "Waiting for the node\xE2\x80\xA6";
|
||||
strings_["merge_wait_locked"] = "The wallet is locked. Unlock it to continue.";
|
||||
strings_["merge_scope_failed_fmt"] = "Couldn't read your inputs: %s";
|
||||
strings_["merge_source"] = "Consolidate";
|
||||
strings_["merge_src_transparent"] = "Transparent";
|
||||
strings_["merge_src_shielded"] = "Shielded";
|
||||
@@ -2535,6 +2539,7 @@ void I18n::loadBuiltinEnglish()
|
||||
strings_["merge_keep_each_status_failed"] = "%s — failed: %s";
|
||||
strings_["merge_keep_each_status_done"] = "%s — done: %d notes merged in %d batch(es)";
|
||||
strings_["merge_keep_each_status_running"] = "%s — merging %d notes (%d of %d batches done)…";
|
||||
strings_["merge_keep_each_status_unconfirmed"] = "%s \xE2\x80\x94 status could not be confirmed";
|
||||
strings_["merge_keep_each_run_again"] = "Addresses merged in several batches now hold one note per batch. Run this again after those confirm to merge them into one.";
|
||||
strings_["done"] = "Done";
|
||||
|
||||
|
||||
+351
-2
@@ -1652,9 +1652,10 @@ void testNetworkRefreshRpcCollectors()
|
||||
coreFallbackRpc.addResponse("getblockchaininfo", json{{"blocks", 8}, {"headers", 9}});
|
||||
auto partialCore = Refresh::collectCoreRefreshResult(coreFallbackRpc);
|
||||
// No longestchain in the response → not classified as "behind" → balance is still attempted (here it
|
||||
// fails). getblockchaininfo is still issued first.
|
||||
// fails). getblockchaininfo is still issued first. The minconf=1 call follows only a minconf=0 call
|
||||
// that succeeded (its result would be dropped anyway).
|
||||
EXPECT_TRUE(coreFallbackRpc.methodNames() == std::vector<std::string>({
|
||||
"getblockchaininfo", "z_gettotalbalance", "z_gettotalbalance"
|
||||
"getblockchaininfo", "z_gettotalbalance"
|
||||
}));
|
||||
EXPECT_FALSE(partialCore.balanceOk);
|
||||
EXPECT_TRUE(partialCore.blockchainOk);
|
||||
@@ -4504,6 +4505,8 @@ void testConsolidationStringsTranslated()
|
||||
"merge_keep_each_confirm_fmt", "merge_keep_each_select", "merge_keep_each_nothing_submitted",
|
||||
"merge_keep_each_some_failed", "merge_keep_each_status_not_started", "merge_keep_each_status_failed",
|
||||
"merge_keep_each_status_done", "merge_keep_each_status_running", "merge_keep_each_run_again",
|
||||
"merge_waiting_node", "merge_wait_locked", "merge_scope_failed_fmt", "retry",
|
||||
"merge_keep_each_status_unconfirmed", "merge_submit_uncertain",
|
||||
});
|
||||
}
|
||||
|
||||
@@ -9496,6 +9499,347 @@ void testBalanceDisplayLerp()
|
||||
}
|
||||
}
|
||||
|
||||
// C47: the spendable (minconf=1) z_gettotalbalance is a second whole-wallet scan under cs_main. It runs
|
||||
// only after the minconf=0 call succeeded, and only when its answer can differ from it: something is
|
||||
// unconfirmed or pending (needSpendable), or the exact total moved since the last poll.
|
||||
void testCoreRefreshBalancePlan()
|
||||
{
|
||||
using Refresh = dragonx::services::NetworkRefreshService;
|
||||
using json = nlohmann::json;
|
||||
using dragonx::rpc::RpcFailureKind;
|
||||
using dragonx::rpc::RpcTransportError;
|
||||
const json chain = json{{"blocks", 150}, {"headers", 150}, {"longestchain", 150}, {"bestblockhash", "tip-150"}};
|
||||
const json total = json{{"private", "3.00000000"}, {"transparent", "1.25000000"}, {"total", "4.25000000"}};
|
||||
const json spendable = json{{"private", "2.00000000"}, {"transparent", "1.25000000"}, {"total", "3.25000000"}};
|
||||
const std::vector<std::string> oneCall = {"getblockchaininfo", "z_gettotalbalance"};
|
||||
const std::vector<std::string> twoCalls = {"getblockchaininfo", "z_gettotalbalance", "z_gettotalbalance"};
|
||||
|
||||
{ // Nothing pending and the total unchanged: one balance call, and spendable is the display total.
|
||||
MockRefreshRpc rpc;
|
||||
rpc.addResponse("getblockchaininfo", chain);
|
||||
rpc.addResponse("z_gettotalbalance", total);
|
||||
Refresh::CoreRefreshPlan plan;
|
||||
plan.needSpendable = false;
|
||||
plan.prevTotalZat = 425000000;
|
||||
auto result = Refresh::collectCoreRefreshResult(rpc, plan);
|
||||
EXPECT_TRUE(rpc.methodNames() == oneCall);
|
||||
EXPECT_EQ(rpc.calls[1].params, json::array({0}));
|
||||
EXPECT_TRUE(result.balanceOk);
|
||||
EXPECT_TRUE(result.balanceAttempted);
|
||||
EXPECT_FALSE(result.spendableQueried);
|
||||
EXPECT_TRUE(result.totalBalanceZat == std::optional<std::int64_t>(425000000));
|
||||
EXPECT_TRUE(Refresh::nextTotalBaseline(result, 425000000) == std::optional<std::int64_t>(425000000));
|
||||
dragonx::WalletState state;
|
||||
Refresh::applyCoreRefreshResult(state, result, 1000);
|
||||
EXPECT_NEAR(state.spendableTotalBalance, 4.25, 1e-9);
|
||||
EXPECT_NEAR(state.unconfirmedBalance, 0.0, 1e-9);
|
||||
}
|
||||
{ // The total moved (how a new 0-conf receive first shows): the spendable call runs.
|
||||
MockRefreshRpc rpc;
|
||||
rpc.addResponse("getblockchaininfo", chain);
|
||||
rpc.addResponse("z_gettotalbalance", total);
|
||||
rpc.addResponse("z_gettotalbalance", spendable);
|
||||
Refresh::CoreRefreshPlan plan;
|
||||
plan.needSpendable = false;
|
||||
plan.prevTotalZat = 325000000;
|
||||
auto result = Refresh::collectCoreRefreshResult(rpc, plan);
|
||||
EXPECT_TRUE(rpc.methodNames() == twoCalls);
|
||||
EXPECT_EQ(rpc.calls[2].params, json::array({1}));
|
||||
EXPECT_TRUE(result.spendableQueried);
|
||||
dragonx::WalletState state;
|
||||
Refresh::applyCoreRefreshResult(state, result, 1000);
|
||||
EXPECT_NEAR(state.spendableTotalBalance, 3.25, 1e-9);
|
||||
EXPECT_NEAR(state.unconfirmedBalance, 1.0, 1e-9);
|
||||
}
|
||||
{ // Something unconfirmed or pending: the spendable call runs although the total held still.
|
||||
MockRefreshRpc rpc;
|
||||
rpc.addResponse("getblockchaininfo", chain);
|
||||
rpc.addResponse("z_gettotalbalance", total);
|
||||
rpc.addResponse("z_gettotalbalance", spendable);
|
||||
Refresh::CoreRefreshPlan plan;
|
||||
plan.needSpendable = true;
|
||||
plan.prevTotalZat = 425000000;
|
||||
Refresh::collectCoreRefreshResult(rpc, plan);
|
||||
EXPECT_TRUE(rpc.methodNames() == twoCalls);
|
||||
}
|
||||
{ // No previous total (first poll, or after a reconnect): the spendable call runs.
|
||||
MockRefreshRpc rpc;
|
||||
rpc.addResponse("getblockchaininfo", chain);
|
||||
rpc.addResponse("z_gettotalbalance", total);
|
||||
rpc.addResponse("z_gettotalbalance", spendable);
|
||||
Refresh::CoreRefreshPlan plan;
|
||||
plan.needSpendable = false;
|
||||
Refresh::collectCoreRefreshResult(rpc, plan);
|
||||
EXPECT_TRUE(rpc.methodNames() == twoCalls);
|
||||
}
|
||||
{ // The display call failed: its result is dropped, so the spendable scan isn't run either.
|
||||
MockRefreshRpc rpc;
|
||||
rpc.addResponse("getblockchaininfo", chain);
|
||||
rpc.addFailure("z_gettotalbalance", "boom");
|
||||
auto result = Refresh::collectCoreRefreshResult(rpc, Refresh::CoreRefreshPlan{});
|
||||
EXPECT_TRUE(rpc.methodNames() == oneCall);
|
||||
EXPECT_FALSE(result.balanceOk);
|
||||
EXPECT_TRUE(result.balanceAttempted); // it reached the daemon
|
||||
EXPECT_FALSE(result.spendableQueried);
|
||||
EXPECT_FALSE(result.totalBalanceZat.has_value());
|
||||
}
|
||||
{ // Held back by the busy gate: never reached the daemon, so a forced refresh must not count it.
|
||||
MockRefreshRpc rpc;
|
||||
rpc.addResponse("getblockchaininfo", chain);
|
||||
rpc.addException("z_gettotalbalance", std::make_exception_ptr(
|
||||
RpcTransportError(RpcFailureKind::Deferred, "held back: the node is busy")));
|
||||
auto result = Refresh::collectCoreRefreshResult(rpc, Refresh::CoreRefreshPlan{});
|
||||
EXPECT_FALSE(result.balanceOk);
|
||||
EXPECT_FALSE(result.balanceAttempted);
|
||||
EXPECT_TRUE(result.balanceErrKind == RpcFailureKind::Deferred);
|
||||
}
|
||||
{ // Behind, or no balance asked for: the chain call only, nothing attempted.
|
||||
MockRefreshRpc rpc;
|
||||
rpc.addResponse("getblockchaininfo", json{{"blocks", 100}, {"headers", 150}, {"longestchain", 150}});
|
||||
auto behind = Refresh::collectCoreRefreshResult(rpc, Refresh::CoreRefreshPlan{});
|
||||
EXPECT_TRUE(rpc.methodNames() == std::vector<std::string>({"getblockchaininfo"}));
|
||||
EXPECT_FALSE(behind.balanceAttempted);
|
||||
MockRefreshRpc chainOnly;
|
||||
chainOnly.addResponse("getblockchaininfo", chain);
|
||||
Refresh::CoreRefreshPlan plan;
|
||||
plan.includeBalance = false;
|
||||
auto skipped = Refresh::collectCoreRefreshResult(chainOnly, plan);
|
||||
EXPECT_TRUE(chainOnly.methodNames() == std::vector<std::string>({"getblockchaininfo"}));
|
||||
EXPECT_FALSE(skipped.balanceAttempted);
|
||||
EXPECT_TRUE(Refresh::nextTotalBaseline(skipped, 425000000) == std::optional<std::int64_t>(425000000));
|
||||
}
|
||||
// The total moved but the minconf=1 call brought nothing back (an error, or held back by the busy gate):
|
||||
// spendable degrades to display, so the baseline is dropped and the next poll measures it again
|
||||
// instead of skipping it while the total holds still.
|
||||
for (int heldBack = 0; heldBack < 2; ++heldBack) {
|
||||
MockRefreshRpc rpc;
|
||||
rpc.addResponse("getblockchaininfo", chain);
|
||||
rpc.addResponse("z_gettotalbalance", total);
|
||||
if (heldBack) {
|
||||
rpc.addException("z_gettotalbalance", std::make_exception_ptr(
|
||||
RpcTransportError(RpcFailureKind::Deferred, "held back: the node is busy")));
|
||||
} else {
|
||||
rpc.addFailure("z_gettotalbalance", "boom");
|
||||
}
|
||||
Refresh::CoreRefreshPlan plan;
|
||||
plan.needSpendable = false;
|
||||
plan.prevTotalZat = 325000000;
|
||||
auto result = Refresh::collectCoreRefreshResult(rpc, plan);
|
||||
EXPECT_TRUE(rpc.methodNames() == twoCalls);
|
||||
EXPECT_TRUE(result.balanceOk);
|
||||
EXPECT_TRUE(result.spendableQueried);
|
||||
EXPECT_FALSE(result.spendableTotalBalance.has_value());
|
||||
dragonx::WalletState state;
|
||||
Refresh::applyCoreRefreshResult(state, result, 1000);
|
||||
EXPECT_NEAR(state.spendableTotalBalance, 4.25, 1e-9);
|
||||
EXPECT_NEAR(state.unconfirmedBalance, 0.0, 1e-9);
|
||||
const auto baseline = Refresh::nextTotalBaseline(result, plan.prevTotalZat);
|
||||
EXPECT_FALSE(baseline.has_value());
|
||||
|
||||
// The next poll: no baseline, so the spendable call runs again and finds the unconfirmed funds.
|
||||
MockRefreshRpc retry;
|
||||
retry.addResponse("getblockchaininfo", chain);
|
||||
retry.addResponse("z_gettotalbalance", total);
|
||||
retry.addResponse("z_gettotalbalance", spendable);
|
||||
Refresh::CoreRefreshPlan next;
|
||||
next.needSpendable = false;
|
||||
next.prevTotalZat = baseline;
|
||||
auto healed = Refresh::collectCoreRefreshResult(retry, next);
|
||||
EXPECT_TRUE(retry.methodNames() == twoCalls);
|
||||
dragonx::WalletState healedState;
|
||||
Refresh::applyCoreRefreshResult(healedState, healed, 1001);
|
||||
EXPECT_NEAR(healedState.unconfirmedBalance, 1.0, 1e-9);
|
||||
EXPECT_TRUE(Refresh::nextTotalBaseline(healed, baseline) == std::optional<std::int64_t>(425000000));
|
||||
}
|
||||
}
|
||||
|
||||
// Exact daemon amounts in zatoshis, so "did the total move" never trips on floating-point rounding.
|
||||
void testParseMoneyZat()
|
||||
{
|
||||
using Refresh = dragonx::services::NetworkRefreshService;
|
||||
using Z = std::optional<std::int64_t>;
|
||||
EXPECT_TRUE(Refresh::parseMoneyZat("4.25000000") == Z(425000000));
|
||||
EXPECT_TRUE(Refresh::parseMoneyZat("0.00000000") == Z(0));
|
||||
EXPECT_TRUE(Refresh::parseMoneyZat("12") == Z(1200000000));
|
||||
EXPECT_TRUE(Refresh::parseMoneyZat("0.1") == Z(10000000));
|
||||
EXPECT_TRUE(Refresh::parseMoneyZat("0.00000001") == Z(1));
|
||||
EXPECT_TRUE(Refresh::parseMoneyZat("-1.50000000") == Z(-150000000));
|
||||
EXPECT_TRUE(Refresh::parseMoneyZat("92233720367.99999999") == Z(9223372036799999999LL));
|
||||
EXPECT_FALSE(Refresh::parseMoneyZat("9999999999999999999").has_value()); // would overflow
|
||||
EXPECT_FALSE(Refresh::parseMoneyZat("").has_value());
|
||||
EXPECT_FALSE(Refresh::parseMoneyZat("-").has_value());
|
||||
EXPECT_FALSE(Refresh::parseMoneyZat(".5").has_value());
|
||||
EXPECT_FALSE(Refresh::parseMoneyZat("1.").has_value());
|
||||
EXPECT_FALSE(Refresh::parseMoneyZat("1.123456789").has_value()); // finer than a zatoshi
|
||||
EXPECT_FALSE(Refresh::parseMoneyZat("1e5").has_value());
|
||||
EXPECT_FALSE(Refresh::parseMoneyZat(" 1.0").has_value());
|
||||
EXPECT_FALSE(Refresh::parseMoneyZat("1.0 ").has_value());
|
||||
}
|
||||
|
||||
void testSpendableBalanceNeeded()
|
||||
{
|
||||
using Refresh = dragonx::services::NetworkRefreshService;
|
||||
dragonx::WalletState state;
|
||||
EXPECT_TRUE(Refresh::spendableBalanceNeeded(state, false, false)); // never fetched
|
||||
state.last_balance_update = 1000;
|
||||
EXPECT_FALSE(Refresh::spendableBalanceNeeded(state, false, false));
|
||||
EXPECT_TRUE(Refresh::spendableBalanceNeeded(state, true, false)); // a send in flight
|
||||
EXPECT_TRUE(Refresh::spendableBalanceNeeded(state, false, true)); // forced (the user's own send)
|
||||
state.unconfirmedBalance = 0.5;
|
||||
EXPECT_TRUE(Refresh::spendableBalanceNeeded(state, false, false));
|
||||
state.unconfirmedBalance = 0.0;
|
||||
dragonx::AddressInfo z;
|
||||
z.address = "zs-one";
|
||||
z.balance = 2.0;
|
||||
z.spendableBalance = 1.0; // the address scan saw unconfirmed funds
|
||||
state.z_addresses.push_back(z);
|
||||
EXPECT_TRUE(Refresh::spendableBalanceNeeded(state, false, false));
|
||||
state.z_addresses[0].spendableBalance = 2.0;
|
||||
EXPECT_FALSE(Refresh::spendableBalanceNeeded(state, false, false));
|
||||
dragonx::AddressInfo t;
|
||||
t.address = "R-one";
|
||||
t.balance = 1.0;
|
||||
t.spendableBalance = 0.0;
|
||||
state.t_addresses.push_back(t);
|
||||
EXPECT_TRUE(Refresh::spendableBalanceNeeded(state, false, false));
|
||||
}
|
||||
|
||||
// C34: z_getoperationstatus filtered to our opids. Its one argument is an ARRAY of ids, so the params are
|
||||
// [[id, ...]]; the old ["id"] attempt was rejected. An empty filter would mean every op, so none at all.
|
||||
void testOperationFilterParams()
|
||||
{
|
||||
using Refresh = dragonx::services::NetworkRefreshService;
|
||||
auto one = Refresh::buildOperationFilterParams({"opid-1"});
|
||||
EXPECT_TRUE(one.has_value());
|
||||
EXPECT_EQ(one->dump(), std::string("[[\"opid-1\"]]"));
|
||||
auto two = Refresh::buildOperationFilterParams({"a", "", "b"});
|
||||
EXPECT_TRUE(two.has_value());
|
||||
EXPECT_EQ(two->dump(), std::string("[[\"a\",\"b\"]]"));
|
||||
EXPECT_FALSE(Refresh::buildOperationFilterParams({}).has_value());
|
||||
EXPECT_FALSE(Refresh::buildOperationFilterParams({""}).has_value());
|
||||
}
|
||||
|
||||
// C211: the Merge/Consolidate dialog's scope scan (listunspent + z_listunspent, two whole-wallet scans)
|
||||
// used to be re-posted on the frame after any failure, forever on Lite. One scan at a time, a failure
|
||||
// latches until Retry, and only "node not ready" failures retry by themselves (backed off, 3 times).
|
||||
void testScopeScanAndLockedNotes()
|
||||
{
|
||||
using namespace dragonx::services;
|
||||
using dragonx::rpc::RpcFailureKind;
|
||||
ScopeScan scan;
|
||||
ScopeInputs in;
|
||||
in.mergeMode = true;
|
||||
in.nodeReady = true;
|
||||
in.now = 100.0;
|
||||
scopeScanOpen(scan, 100.0);
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::Post);
|
||||
in.mergeMode = false;
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::Nothing);
|
||||
in.mergeMode = true;
|
||||
in.nodeReady = false;
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::WaitNode);
|
||||
in.nodeReady = true;
|
||||
in.busyWithOp = true;
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::Nothing);
|
||||
in.busyWithOp = false;
|
||||
|
||||
auto gen = scopeScanBegin(scan, 100.0);
|
||||
EXPECT_TRUE(scan.phase == ScopePhase::Loading);
|
||||
EXPECT_TRUE(scan.inFlight);
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::Nothing); // one scan at a time
|
||||
|
||||
// A real error latches until Retry: no re-scan by itself, whenever the next frame comes.
|
||||
EXPECT_FALSE(scopeScanFinish(scan, gen, "Insufficient permissions", RpcFailureKind::AppError, 101.0));
|
||||
EXPECT_TRUE(scan.phase == ScopePhase::Failed);
|
||||
EXPECT_FALSE(scan.inFlight);
|
||||
EXPECT_FALSE(scan.autoRetry);
|
||||
in.now = 10000.0;
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::Nothing);
|
||||
scopeScanRetry(scan);
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::Post);
|
||||
// ...as does a reply timeout (the daemon is still running that scan).
|
||||
gen = scopeScanBegin(scan, 10000.0);
|
||||
EXPECT_FALSE(scopeScanFinish(scan, gen, "Timeout was reached", RpcFailureKind::ReplyTimeout, 10001.0));
|
||||
EXPECT_FALSE(scan.autoRetry);
|
||||
in.now = 20000.0;
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::Nothing);
|
||||
|
||||
// Node not ready: retries by itself after 10, 30 and 60 s, then latches.
|
||||
scopeScanRetry(scan);
|
||||
gen = scopeScanBegin(scan, 20000.0);
|
||||
scopeScanFinish(scan, gen, "Could not connect", RpcFailureKind::NotListening, 20000.0);
|
||||
EXPECT_TRUE(scan.autoRetry);
|
||||
in.now = 20009.0;
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::WaitBackoff);
|
||||
in.now = 20010.0;
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::Post);
|
||||
gen = scopeScanBegin(scan, 20010.0);
|
||||
scopeScanFinish(scan, gen, "Could not connect", RpcFailureKind::NotListening, 20010.0);
|
||||
in.now = 20039.0;
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::WaitBackoff);
|
||||
in.now = 20040.0;
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::Post);
|
||||
gen = scopeScanBegin(scan, 20040.0);
|
||||
scopeScanFinish(scan, gen, "Could not connect", RpcFailureKind::NotListening, 20040.0);
|
||||
EXPECT_NEAR(scan.retryAt, 20100.0, 1e-9);
|
||||
in.now = 20100.0;
|
||||
gen = scopeScanBegin(scan, 20100.0);
|
||||
scopeScanFinish(scan, gen, "Could not connect", RpcFailureKind::NotListening, 20100.0);
|
||||
EXPECT_FALSE(scan.autoRetry); // a 4th failure: wait for Retry
|
||||
in.now = 30000.0;
|
||||
EXPECT_TRUE(scopeScanWant(scan, in) == ScopeWant::Nothing);
|
||||
EXPECT_TRUE(scopeFailureRetries(RpcFailureKind::Other, "Not connected"));
|
||||
EXPECT_FALSE(scopeFailureRetries(RpcFailureKind::Other, "[json.exception.type_error.302] type must be number"));
|
||||
|
||||
// A result from an earlier session (the connection changed meanwhile) is dropped, but frees the guard.
|
||||
ScopeScan old;
|
||||
scopeScanOpen(old, 0.0);
|
||||
const auto oldGen = scopeScanBegin(old, 0.0);
|
||||
scopeScanInvalidate(old);
|
||||
EXPECT_TRUE(old.inFlight);
|
||||
in.now = 1.0;
|
||||
EXPECT_TRUE(scopeScanWant(old, in) == ScopeWant::Nothing); // the old scan still runs in the daemon
|
||||
EXPECT_FALSE(scopeScanFinish(old, oldGen, "", RpcFailureKind::None, 1.0));
|
||||
EXPECT_FALSE(old.inFlight);
|
||||
EXPECT_TRUE(old.phase == ScopePhase::Idle);
|
||||
EXPECT_TRUE(scopeScanWant(old, in) == ScopeWant::Post);
|
||||
|
||||
// Closing and reopening while a scan loads adopts it (no second pair of scans)...
|
||||
ScopeScan adopt;
|
||||
scopeScanOpen(adopt, 0.0);
|
||||
const auto adoptGen = scopeScanBegin(adopt, 0.0);
|
||||
scopeScanOpen(adopt, 5.0);
|
||||
EXPECT_TRUE(adopt.gen == adoptGen);
|
||||
EXPECT_TRUE(adopt.inFlight);
|
||||
EXPECT_TRUE(scopeScanFinish(adopt, adoptGen, "", RpcFailureKind::None, 6.0));
|
||||
EXPECT_TRUE(adopt.phase == ScopePhase::Loaded);
|
||||
// ...unless it has been outstanding past the limit: presumed lost, a new session starts.
|
||||
ScopeScan lost;
|
||||
scopeScanOpen(lost, 0.0);
|
||||
const auto lostGen = scopeScanBegin(lost, 0.0);
|
||||
scopeScanOpen(lost, kScopeInFlightMaxSec + 1.0);
|
||||
EXPECT_TRUE(lost.gen != lostGen);
|
||||
EXPECT_FALSE(lost.inFlight);
|
||||
const auto freshGen = scopeScanBegin(lost, kScopeInFlightMaxSec + 2.0);
|
||||
EXPECT_FALSE(scopeScanFinish(lost, lostGen, "", RpcFailureKind::None, kScopeInFlightMaxSec + 3.0));
|
||||
EXPECT_TRUE(lost.inFlight); // the late result doesn't clear the fresh scan's guard
|
||||
EXPECT_TRUE(scopeScanFinish(lost, freshGen, "", RpcFailureKind::None, kScopeInFlightMaxSec + 4.0));
|
||||
|
||||
// Locked notes (held by an operation in flight) can't be merged, so they aren't counted.
|
||||
using json = nlohmann::json;
|
||||
const json notes = json::array({
|
||||
json{{"address", "zs-a"}, {"confirmations", 3}, {"amount", 1.0}},
|
||||
json{{"address", "zs-a"}, {"confirmations", 3}, {"amount", 1.0}, {"locked", true}},
|
||||
json{{"address", "zs-a"}, {"confirmations", 3}, {"amount", 1.0}, {"locked", false}},
|
||||
});
|
||||
const auto groups = groupSpendableNotes(notes);
|
||||
EXPECT_EQ(groups.size(), static_cast<size_t>(1));
|
||||
EXPECT_EQ(groups[0].notes, 2);
|
||||
EXPECT_TRUE(noteIsLocked(json{{"locked", true}}));
|
||||
EXPECT_FALSE(noteIsLocked(json{{"locked", "yes"}}));
|
||||
EXPECT_FALSE(noteIsLocked(json::array()));
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
testConnectionConfig();
|
||||
@@ -9515,6 +9859,10 @@ int main()
|
||||
testNetworkRefreshSnapshotHelpers();
|
||||
testParseDaemonRescanOutput();
|
||||
testNetworkRefreshRpcCollectors();
|
||||
testCoreRefreshBalancePlan();
|
||||
testParseMoneyZat();
|
||||
testSpendableBalanceNeeded();
|
||||
testOperationFilterParams();
|
||||
testNetworkRefreshResultModels();
|
||||
testTrackedSendRetirement();
|
||||
testBalanceDisplayLerp();
|
||||
@@ -9530,6 +9878,7 @@ int main()
|
||||
testOwnershipRecord();
|
||||
testDebugLogTailRules();
|
||||
testNoteConsolidation();
|
||||
testScopeScanAndLockedNotes();
|
||||
testStopDeliveryPolicy();
|
||||
testProcStatParse();
|
||||
testStopProgressTracker();
|
||||
|
||||
Reference in New Issue
Block a user