refactor: defer active_ctx block tip init until after nodeman->Init()

Move InitializeCurrentBlockTip for active_ctx (masternode mode) to
after nodeman->Init() so that GetProTxHash() is guaranteed to be set
before EnsureQuorumConnections runs.

Currently this works by accident: UpdatedBlockTip calls Init()
internally when the MN state is not READY. But this is a non-obvious
side effect and would silently break quorum connections if someone
refactored UpdatedBlockTip to add an early return. Also, if
IsInitialBlockDownload() is true, UpdatedBlockTip returns early and
Init() never runs, leaving a null proTxHash for quorum setup.

Making the dependency explicit improves robustness without changing
observable behavior in normal operation.

Also add a MN-to-MN quorum connection assertion in the restart test
to verify that quorum connections form between masternodes after
restart, not just that IS locks work (which can succeed via
concentrated sigshare sending over any authenticated connection).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: UdjinM6

src/init.cpp

@@ -2420,11 +2420,11 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         {
             const CBlockIndex* tip = WITH_LOCK(::cs_main, return chainman.ActiveTip());
             const bool ibd = chainman.ActiveChainstate().IsInitialBlockDownload();
-            if (node.active_ctx) {
-                node.active_ctx->InitializeCurrentBlockTip(tip, ibd);
-            } else if (node.observer_ctx) {
+            if (node.observer_ctx && !node.active_ctx) {
                 node.observer_ctx->InitializeCurrentBlockTip(tip, ibd);
             }
+            // Note: active_ctx initialization is deferred until after nodeman->Init()
+            // so that GetProTxHash() is available for quorum connection setup.
         }
 
         {
@@ -2490,6 +2490,13 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
         if (node.active_ctx) {
             node.active_ctx->nodeman->Init(chainman.ActiveTip());
+            // Initialize current block tip after nodeman->Init() so that
+            // GetProTxHash() is available for quorum connection setup.
+            // Without this ordering, EnsureQuorumConnections returns early
+            // because the null proTxHash makes the MN appear as a non-member.
+            const CBlockIndex* tip = WITH_LOCK(::cs_main, return chainman.ActiveTip());
+            const bool ibd = chainman.ActiveChainstate().IsInitialBlockDownload();
+            node.active_ctx->InitializeCurrentBlockTip(tip, ibd);
         }
     });
 #ifdef ENABLE_WALLET

test/functional/p2p_instantsend.py

@@ -174,8 +174,10 @@ def test_instantsend_after_restart(self):
         for mn_info in self.mninfo:
             self.start_masternode(mn_info)
 
-        # reconnect: simple nodes to node 0, MNs to node 0
-        # quorum connections are re-established automatically via InitializeCurrentBlockTip
+        # reconnect: simple nodes to node 0, MNs to node 0 only.
+        # Quorum connections between MNs must be re-established automatically
+        # via InitializeCurrentBlockTip → EnsureQuorumConnections, NOT via
+        # manual connect_nodes between MN pairs.
         for i in range(1, num_simple_nodes):
             self.connect_nodes(i, 0)
         for mn_info in self.mninfo:
@@ -188,6 +190,22 @@ def test_instantsend_after_restart(self):
         self.bump_mocktime(10 * 60 + 1)
         self.sync_blocks()
 
+        # Verify that MNs formed quorum connections to other MNs after restart.
+        # InitializeCurrentBlockTip → EnsureQuorumConnections must populate
+        # masternodeQuorumNodes so ThreadOpenMasternodeConnections establishes
+        # MN-to-MN links beyond the manual connections to node 0.
+        self.log.info("Verifying MN-to-MN quorum connections formed after restart")
+        for mn_info in self.mninfo:
+            mn_node = self.nodes[mn_info.nodeIdx]
+
+            def check_mn_peers(node=mn_node, my_hash=mn_info.proTxHash):
+                peers = node.getpeerinfo()
+                mn_peers = set(p['verified_proregtx_hash'] for p in peers
+                               if p.get('verified_proregtx_hash', '') != '')
+                other_mn_peers = mn_peers - {my_hash}
+                return len(other_mn_peers) > 0
+            self.wait_until(check_mn_peers, timeout=30)
+
         # re-grab references after restart
         sender = self.nodes[self.sender_idx]
         receiver = self.nodes[self.receiver_idx]