cpp: Introduce Rewind Progress handler and nofifier

This introduces a Rewind Progress notification so that it is available when generating an AssumeUTXO snapshot through the UI.

Author: D33r-Gee

Diff for: src/interfaces/node.h

@@ -251,6 +251,10 @@ class Node
     using SnapshotLoadProgressFn = std::function<void(double progress)>;
     virtual std::unique_ptr<Handler> handleSnapshotLoadProgress(SnapshotLoadProgressFn fn) = 0;
 
+    //! Register handler for rewind progress messages.
+    using RewindProgressFn = std::function<void(double progress)>;
+    virtual std::unique_ptr<Handler> handleRewindProgress(RewindProgressFn fn) = 0;
+
     //! Register handler for wallet loader constructed messages.
     using InitWalletFn = std::function<void()>;
     virtual std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn) = 0;

Diff for: src/kernel/notifications_interface.h

@@ -39,8 +39,10 @@ class Notifications
 
     [[nodiscard]] virtual InterruptResult blockTip(SynchronizationState state, CBlockIndex& index) { return {}; }
     virtual void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) {}
+    virtual void blockTipDisconnected(SynchronizationState state, CBlockIndex& index) {}
     virtual void progress(const bilingual_str& title, int progress_percent, bool resume_possible) {}
     virtual void snapshotLoadProgress(double progress) {}
+    virtual void rewindProgress(double progress) {}
     virtual void warning(const bilingual_str& warning) {}
 
     //! The flush error notification is sent to notify the user that an error

Diff for: src/node/interface_ui.cpp

@@ -22,8 +22,10 @@ struct UISignals {
     boost::signals2::signal<CClientUIInterface::NotifyAlertChangedSig> NotifyAlertChanged;
     boost::signals2::signal<CClientUIInterface::ShowProgressSig> ShowProgress;
     boost::signals2::signal<CClientUIInterface::SnapshotLoadProgressSig> SnapshotLoadProgress;
+    boost::signals2::signal<CClientUIInterface::RewindProgressSig> RewindProgress;
     boost::signals2::signal<CClientUIInterface::NotifyBlockTipSig> NotifyBlockTip;
     boost::signals2::signal<CClientUIInterface::NotifyHeaderTipSig> NotifyHeaderTip;
+    boost::signals2::signal<CClientUIInterface::NotifyBlockDisconnectedSig> NotifyBlockDisconnected;
     boost::signals2::signal<CClientUIInterface::BannedListChangedSig> BannedListChanged;
 };
 static UISignals g_ui_signals;
@@ -44,9 +46,10 @@ ADD_SIGNALS_IMPL_WRAPPER(NotifyAlertChanged);
 ADD_SIGNALS_IMPL_WRAPPER(ShowProgress);
 ADD_SIGNALS_IMPL_WRAPPER(NotifyBlockTip);
 ADD_SIGNALS_IMPL_WRAPPER(NotifyHeaderTip);
+ADD_SIGNALS_IMPL_WRAPPER(NotifyBlockDisconnected);
 ADD_SIGNALS_IMPL_WRAPPER(BannedListChanged);
 ADD_SIGNALS_IMPL_WRAPPER(SnapshotLoadProgress);
-
+ADD_SIGNALS_IMPL_WRAPPER(RewindProgress);
 bool CClientUIInterface::ThreadSafeMessageBox(const bilingual_str& message, const std::string& caption, unsigned int style) { return g_ui_signals.ThreadSafeMessageBox(message, caption, style).value_or(false);}
 bool CClientUIInterface::ThreadSafeQuestion(const bilingual_str& message, const std::string& non_interactive_message, const std::string& caption, unsigned int style) { return g_ui_signals.ThreadSafeQuestion(message, non_interactive_message, caption, style).value_or(false);}
 void CClientUIInterface::InitMessage(const std::string& message) { return g_ui_signals.InitMessage(message); }
@@ -56,8 +59,10 @@ void CClientUIInterface::NotifyNetworkActiveChanged(bool networkActive) { return
 void CClientUIInterface::NotifyAlertChanged() { return g_ui_signals.NotifyAlertChanged(); }
 void CClientUIInterface::ShowProgress(const std::string& title, int nProgress, bool resume_possible) { return g_ui_signals.ShowProgress(title, nProgress, resume_possible); }
 void CClientUIInterface::SnapshotLoadProgress(double progress) { return g_ui_signals.SnapshotLoadProgress(progress); }
+void CClientUIInterface::RewindProgress(double progress) { return g_ui_signals.RewindProgress(progress); }
 void CClientUIInterface::NotifyBlockTip(SynchronizationState s, const CBlockIndex* i) { return g_ui_signals.NotifyBlockTip(s, i); }
 void CClientUIInterface::NotifyHeaderTip(SynchronizationState s, int64_t height, int64_t timestamp, bool presync) { return g_ui_signals.NotifyHeaderTip(s, height, timestamp, presync); }
+void CClientUIInterface::NotifyBlockDisconnected(SynchronizationState s, const CBlockIndex* i) { return g_ui_signals.NotifyBlockDisconnected(s, i); }
 void CClientUIInterface::BannedListChanged() { return g_ui_signals.BannedListChanged(); }
 
 bool InitError(const bilingual_str& str)

Diff for: src/node/interface_ui.h

@@ -112,12 +112,18 @@ class CClientUIInterface
     /** Snapshot load progress. */
     ADD_SIGNALS_DECL_WRAPPER(SnapshotLoadProgress, void, double progress);
 
+    /** Rewind progress. */
+    ADD_SIGNALS_DECL_WRAPPER(RewindProgress, void, double progress);
+
     /** New block has been accepted */
     ADD_SIGNALS_DECL_WRAPPER(NotifyBlockTip, void, SynchronizationState, const CBlockIndex*);
 
     /** Best header has changed */
     ADD_SIGNALS_DECL_WRAPPER(NotifyHeaderTip, void, SynchronizationState, int64_t height, int64_t timestamp, bool presync);
 
+    /** Block disconnected */
+    ADD_SIGNALS_DECL_WRAPPER(NotifyBlockDisconnected, void, SynchronizationState, const CBlockIndex*);
+
     /** Banlist did change. */
     ADD_SIGNALS_DECL_WRAPPER(BannedListChanged, void, void);
 };

Diff for: src/node/interfaces.cpp

@@ -383,6 +383,10 @@ class NodeImpl : public Node
     {
         return MakeSignalHandler(::uiInterface.SnapshotLoadProgress_connect(fn));
     }
+    std::unique_ptr<Handler> handleRewindProgress(RewindProgressFn fn) override
+    {
+        return MakeSignalHandler(::uiInterface.RewindProgress_connect(fn));
+    }
     std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn) override
     {
         return MakeSignalHandler(::uiInterface.InitWallet_connect(fn));

Diff for: src/node/kernel_notifications.cpp

@@ -83,6 +83,11 @@ void KernelNotifications::snapshotLoadProgress(double progress)
     uiInterface.SnapshotLoadProgress(progress);
 }
 
+void KernelNotifications::rewindProgress(double progress)
+{
+    uiInterface.RewindProgress(progress);
+}
+
 void KernelNotifications::warning(const bilingual_str& warning)
 {
     DoWarning(warning);

Diff for: src/node/kernel_notifications.h

@@ -33,6 +33,8 @@ class KernelNotifications : public kernel::Notifications
 
     void snapshotLoadProgress(double progress) override;
 
+    void rewindProgress(double progress) override;
+
     void warning(const bilingual_str& warning) override;
 
     void flushError(const std::string& debug_message) override;

Diff for: src/validation.cpp

@@ -2661,6 +2661,7 @@ void Chainstate::UpdateTip(const CBlockIndex* pindexNew)
             }
         }
     }
+    m_chainman.GetNotifications().rewindProgress(GuessVerificationProgress(params.TxData(), pindexNew));
     UpdateTipLog(coins_tip, pindexNew, params, __func__, "", warning_messages.original);
 }