Additional changes for GetAdjustedTime

vijaydasmp · vijaydasmp · commit 9c1b91e85147 · 2025-12-04T20:17:42.000+05:30
diff --git a/src/coinjoin/coinjoin.h b/src/coinjoin/coinjoin.h
@@ -212,7 +212,7 @@ class CCoinJoinQueue
     [[nodiscard]] bool CheckSignature(const CBLSPublicKey& blsPubKey) const;
 
     /// Check if a queue is too old or too far into the future
-    [[nodiscard]] bool IsTimeOutOfBounds(int64_t current_time = GetAdjustedTime()) const;
+    [[nodiscard]] bool IsTimeOutOfBounds(int64_t current_time = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime())) const;
 
     [[nodiscard]] std::string ToString() const;
 
diff --git a/src/coinjoin/server.cpp b/src/coinjoin/server.cpp
@@ -360,7 +360,7 @@ void CCoinJoinServer::CommitFinalTransaction()
     // create and sign masternode dstx transaction
     if (!m_dstxman.GetDSTX(hashTx)) {
         CCoinJoinBroadcastTx dstxNew(finalTransaction, m_mn_activeman.GetOutPoint(), m_mn_activeman.GetProTxHash(),
-                                     GetAdjustedTime());
+                                     TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime()));
         dstxNew.vchSig = m_mn_activeman.SignBasic(dstxNew.GetSignatureHash());
         m_dstxman.AddDSTX(dstxNew);
     }
@@ -517,7 +517,7 @@ void CCoinJoinServer::CheckForCompleteQueue()
         SetState(POOL_STATE_ACCEPTING_ENTRIES);
 
         CCoinJoinQueue dsq(nSessionDenom, m_mn_activeman.GetOutPoint(), m_mn_activeman.GetProTxHash(),
-                           GetAdjustedTime(), true);
+                           TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime()), true);
         LogPrint(BCLog::COINJOIN, "CCoinJoinServer::CheckForCompleteQueue -- queue is ready, signing and relaying (%s) " /* Continued */
                                      "with %d participants\n", dsq.ToString(), vecSessionCollaterals.size());
         dsq.vchSig = m_mn_activeman.SignBasic(dsq.GetSignatureHash());
@@ -728,7 +728,7 @@ bool CCoinJoinServer::CreateNewSession(const CCoinJoinAccept& dsa, PoolMessage&
     if (!fUnitTest) {
         //broadcast that I'm accepting entries, only if it's the first entry through
         CCoinJoinQueue dsq(nSessionDenom, m_mn_activeman.GetOutPoint(), m_mn_activeman.GetProTxHash(),
-                           GetAdjustedTime(), false);
+                           TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime()), false);
         LogPrint(BCLog::COINJOIN, "CCoinJoinServer::CreateNewSession -- signing and relaying new queue: %s\n", dsq.ToString());
         dsq.vchSig = m_mn_activeman.SignBasic(dsq.GetSignatureHash());
         m_peerman.RelayDSQ(dsq);
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
@@ -371,7 +371,7 @@ void CGovernanceManager::CheckOrphanVotes(CGovernanceObject& govobj)
 
     ScopedLockBool guard(cs_store, fRateChecksEnabled, false);
 
-    int64_t nNow = GetAdjustedTime();
+    int64_t nNow = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     const auto tip_mn_list = Assert(m_dmnman)->GetListAtChainTip();
     for (const auto& pairVote : vecVotePairs) {
         const auto& [vote, time] = pairVote;
@@ -860,7 +860,7 @@ bool CGovernanceManager::MasternodeRateCheck(const CGovernanceObject& govobj, bo
 
     const COutPoint& masternodeOutpoint = govobj.GetMasternodeOutpoint();
     int64_t nTimestamp = govobj.GetCreationTime();
-    int64_t nNow = GetAdjustedTime();
+    int64_t nNow = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     int64_t nSuperblockCycleSeconds = Params().GetConsensus().nSuperblockCycle * Params().GetConsensus().nPowTargetSpacing;
 
     std::string strHash = govobj.GetHash().ToString();
@@ -1014,7 +1014,7 @@ void CGovernanceManager::CheckPostponedObjects()
 
 
     // Perform additional relays for triggers
-    int64_t nNow = GetAdjustedTime();
+    int64_t nNow = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     int64_t nSuperblockCycleSeconds = Params().GetConsensus().nSuperblockCycle * Params().GetConsensus().nPowTargetSpacing;
 
     for (auto it = setAdditionalRelayObjects.begin(); it != setAdditionalRelayObjects.end();) {
diff --git a/src/governance/object.cpp b/src/governance/object.cpp
@@ -120,7 +120,7 @@ bool CGovernanceObject::ProcessVote(CMasternodeMetaMan& mn_metaman, CGovernanceM
         LogPrint(BCLog::GOBJECT, "%s\n", msg);
     }
 
-    int64_t nNow = GetAdjustedTime();
+    int64_t nNow = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     int64_t nVoteTimeUpdate = voteInstanceRef.nTime;
     if (govman.AreRateChecksEnabled()) {
         int64_t nTimeDelta = nNow - voteInstanceRef.nTime;
diff --git a/src/governance/signing.cpp b/src/governance/signing.cpp
@@ -127,7 +127,7 @@ std::optional<const CGovernanceObject> GovernanceSigner::CreateGovernanceTrigger
     LOCK(::cs_main);
 
     // Check if identical trigger (equal DataHash()) is already created (signed by other masternode)
-    CGovernanceObject gov_sb(uint256(), 1, GetAdjustedTime(), uint256(), sb_opt.value().GetHexStrData());
+    CGovernanceObject gov_sb(uint256(), 1, TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime()), uint256(), sb_opt.value().GetHexStrData());
     if (auto identical_sb = m_govman.FindGovernanceObjectByDataHash(gov_sb.GetDataHash())) {
         // Somebody submitted a trigger with the same data, support it instead of submitting a duplicate
         return std::make_optional<CGovernanceObject>(*identical_sb);
@@ -261,7 +261,7 @@ void GovernanceSigner::VoteGovernanceTriggers(const std::optional<const CGoverna
 bool GovernanceSigner::VoteFundingTrigger(const uint256& nHash, const vote_outcome_enum_t outcome)
 {
     CGovernanceVote vote(m_mn_activeman.GetOutPoint(), nHash, VOTE_SIGNAL_FUNDING, outcome);
-    vote.SetTime(GetAdjustedTime());
+    vote.SetTime(TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime()));
     vote.SetSignature(m_mn_activeman.SignBasic(vote.GetSignatureHash()));
 
     CGovernanceException exception;
diff --git a/src/governance/validators.cpp b/src/governance/validators.cpp
@@ -136,7 +136,7 @@ bool CProposalValidator::ValidateStartEndEpoch(bool fCheckExpiration)
         return false;
     }
 
-    if (fCheckExpiration && nEndEpoch <= GetAdjustedTime()) {
+    if (fCheckExpiration && nEndEpoch <= TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime())) {
         strErrorMessages += "expired;";
         return false;
     }
diff --git a/src/governance/vote.cpp b/src/governance/vote.cpp
@@ -87,7 +87,7 @@ CGovernanceVote::CGovernanceVote(const COutPoint& outpointMasternodeIn, const ui
     nParentHash(nParentHashIn),
     nVoteOutcome(eVoteOutcomeIn),
     nVoteSignal(eVoteSignalIn),
-    nTime(GetAdjustedTime())
+    nTime(TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime()))
 {
     UpdateHash();
 }
@@ -154,8 +154,8 @@ bool CGovernanceVote::CheckSignature(const CBLSPublicKey& pubKey) const
 
 bool CGovernanceVote::IsValid(const CDeterministicMNList& tip_mn_list, bool useVotingKey) const
 {
-    if (nTime > GetAdjustedTime() + (60 * 60)) {
-        LogPrint(BCLog::GOBJECT, "CGovernanceVote::IsValid -- vote is too far ahead of current time - %s - nTime %lli - Max Time %lli\n", GetHash().ToString(), nTime, GetAdjustedTime() + (60 * 60));
+    if (nTime > TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime() + 1h)) {
+        LogPrint(BCLog::GOBJECT, "CGovernanceVote::IsValid -- vote is too far ahead of current time - %s - nTime %lli - Max Time %lli\n", GetHash().ToString(), nTime, TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime() + 1h));
         return false;
     }
 
diff --git a/src/llmq/debug.cpp b/src/llmq/debug.cpp
@@ -154,7 +154,7 @@ void CDKGDebugManager::ResetLocalSessionStatus(Consensus::LLMQType llmqType, int
     }
 
     localStatus.sessions.erase(it);
-    localStatus.nTime = GetAdjustedTime();
+    localStatus.nTime = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
 }
 
 void CDKGDebugManager::InitLocalSessionStatus(const Consensus::LLMQParams& llmqParams, int quorumIndex, const uint256& quorumHash, int quorumHeight)
@@ -186,7 +186,7 @@ void CDKGDebugManager::UpdateLocalSessionStatus(Consensus::LLMQType llmqType, in
     }
 
     if (func(it->second)) {
-        localStatus.nTime = GetAdjustedTime();
+        localStatus.nTime = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     }
 }
 
@@ -200,7 +200,7 @@ void CDKGDebugManager::UpdateLocalMemberStatus(Consensus::LLMQType llmqType, int
     }
 
     if (func(it->second.members.at(memberIdx))) {
-        localStatus.nTime = GetAdjustedTime();
+        localStatus.nTime = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     }
 }
 
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
@@ -6025,7 +6025,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)
                          // Convert HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER to microseconds before scaling
                          // to maintain precision
                          std::chrono::microseconds{HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER} *
-                         Ticks<std::chrono::seconds>(GetAdjustedTime() - m_chainman.m_best_header->Time()) / consensusParams.nPowTargetSpacing
+                         Ticks<std::chrono::seconds>(TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime() - m_chainman.m_best_header->Time())) / consensusParams.nPowTargetSpacing
                         );
                     nSyncStarted++;
                 }
diff --git a/src/rpc/governance.cpp b/src/rpc/governance.cpp
@@ -124,7 +124,7 @@ static RPCHelpMan gobject_check()
 
     int nRevision = 1;
 
-    int64_t nTime = GetAdjustedTime();
+    int64_t nTime = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     std::string strDataHex = request.params[0].get_str();
 
     CGovernanceObject govobj(hashParent, nRevision, nTime, uint256(), strDataHex);
diff --git a/src/spork.cpp b/src/spork.cpp
@@ -145,7 +145,7 @@ MessageProcessingResult CSporkManager::ProcessSpork(NodeId from, CDataStream& vR
     MessageProcessingResult ret{};
     ret.m_to_erase = CInv{MSG_SPORK, hash};
 
-    if (spork.nTimeSigned > GetAdjustedTime() + 2 * 60 * 60) {
+    if (spork.nTimeSigned > TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime() + 2 * 60 * 60)) {
         LogPrint(BCLog::SPORK, "CSporkManager::ProcessSpork -- ERROR: too far into the future\n");
         ret.m_error = MisbehavingError{100};
         return ret;
@@ -207,7 +207,7 @@ void CSporkManager::ProcessGetSporks(CNode& peer, CConnman& connman)
 
 std::optional<CInv> CSporkManager::UpdateSpork(SporkId nSporkID, SporkValue nValue)
 {
-    CSporkMessage spork(nSporkID, nValue, GetAdjustedTime());
+    CSporkMessage spork(nSporkID, nValue, TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime()));
 
     LOCK(cs);
 
@@ -249,7 +249,7 @@ bool CSporkManager::IsSporkActive(SporkId nSporkID) const
 
     SporkValue nSporkValue = GetSporkValue(nSporkID);
     // Get time is somewhat costly it looks like
-    bool ret = nSporkValue < GetAdjustedTime();
+    bool ret = nSporkValue < TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     // Only cache true values
     if (ret) {
         LOCK(cs_cache);
diff --git a/src/test/coinjoin_basemanager_tests.cpp b/src/test/coinjoin_basemanager_tests.cpp
@@ -43,7 +43,7 @@ BOOST_AUTO_TEST_CASE(checkqueue_removes_timeouts)
 {
     TestBaseManager man;
     const int denom = CoinJoin::AmountToDenomination(CoinJoin::GetSmallestDenomination());
-    const int64_t now = GetAdjustedTime();
+    const int64_t now = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     // Non-expired
     man.PushQueue(MakeQueue(denom, now, false, COutPoint(uint256S("11"), 0)));
     // Expired (too old)
@@ -59,7 +59,7 @@ BOOST_AUTO_TEST_CASE(getqueueitem_marks_tried_once)
 {
     TestBaseManager man;
     const int denom = CoinJoin::AmountToDenomination(CoinJoin::GetSmallestDenomination());
-    const int64_t now = GetAdjustedTime();
+    const int64_t now = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     CCoinJoinQueue dsq = MakeQueue(denom, now, false, COutPoint(uint256S("21"), 0));
     man.PushQueue(dsq);
 
diff --git a/src/test/coinjoin_inouts_tests.cpp b/src/test/coinjoin_inouts_tests.cpp
@@ -90,7 +90,7 @@ BOOST_AUTO_TEST_CASE(queue_timeout_bounds)
     CCoinJoinQueue dsq;
     dsq.nDenom = CoinJoin::AmountToDenomination(CoinJoin::GetSmallestDenomination());
     dsq.m_protxHash = uint256::ONE;
-    dsq.nTime = GetAdjustedTime();
+    dsq.nTime = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     // current time -> not out of bounds
     BOOST_CHECK(!dsq.IsTimeOutOfBounds());
 
@@ -100,7 +100,7 @@ BOOST_AUTO_TEST_CASE(queue_timeout_bounds)
 
     // Too far in the future
     SetMockTime(GetTime() - 2 * (COINJOIN_QUEUE_TIMEOUT + 1)); // move back to anchor baseline
-    dsq.nTime = GetAdjustedTime() + (COINJOIN_QUEUE_TIMEOUT + 1);
+    dsq.nTime = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime()) + (COINJOIN_QUEUE_TIMEOUT + 1);
     BOOST_CHECK(dsq.IsTimeOutOfBounds());
 
     // Reset mock time
diff --git a/src/test/coinjoin_queue_tests.cpp b/src/test/coinjoin_queue_tests.cpp
@@ -30,7 +30,7 @@ BOOST_AUTO_TEST_CASE(queue_sign_and_verify)
     q.nDenom = CoinJoin::AmountToDenomination(CoinJoin::GetSmallestDenomination());
     q.masternodeOutpoint = COutPoint(uint256S("aa"), 1);
     q.m_protxHash = uint256::ONE;
-    q.nTime = GetAdjustedTime();
+    q.nTime = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     q.fReady = false;
 
     // Sign and verify with corresponding pubkey
@@ -45,7 +45,7 @@ BOOST_AUTO_TEST_CASE(queue_hashes_and_equality)
     a.nDenom = b.nDenom = CoinJoin::AmountToDenomination(CoinJoin::GetSmallestDenomination());
     a.masternodeOutpoint = b.masternodeOutpoint = COutPoint(uint256S("bb"), 2);
     a.m_protxHash = b.m_protxHash = uint256::ONE;
-    a.nTime = b.nTime = GetAdjustedTime();
+    a.nTime = b.nTime = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
     a.fReady = b.fReady = true;
 
     BOOST_CHECK(a == b);
@@ -72,7 +72,7 @@ BOOST_AUTO_TEST_CASE(queue_timestamp_validation)
     q.masternodeOutpoint = COutPoint(uint256S("cc"), 3);
     q.m_protxHash = uint256::ONE;
 
-    int64_t current_time = GetAdjustedTime();
+    int64_t current_time = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
 
     // Test valid timestamp (current time)
     q.nTime = current_time;
diff --git a/src/validation.cpp b/src/validation.cpp
@@ -4234,7 +4234,7 @@ bool ChainstateManager::AcceptBlockHeader(const CBlockHeader& block, BlockValida
             return state.Invalid(BlockValidationResult::BLOCK_CHAINLOCK, "bad-prevblk-chainlock");
         }
 
-        if (!ContextualCheckBlockHeader(block, state, m_blockman, chainparams, pindexPrev, GetAdjustedTime())) {
+        if (!ContextualCheckBlockHeader(block, state, m_blockman, chainparams, pindexPrev, TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime()))) {
             LogPrint(BCLog::VALIDATION, "%s: Consensus::ContextualCheckBlockHeader: %s, %s\n", __func__, hash.ToString(), state.ToString());
             return false;
         }
@@ -4522,7 +4522,7 @@ bool TestBlockValidity(BlockValidationState& state,
     auto dbTx = evoDb.BeginTransaction();
 
     // NOTE: CheckBlockHeader is called by CheckBlock
-    if (!ContextualCheckBlockHeader(block, state, chainstate.m_blockman, chainparams, pindexPrev, GetAdjustedTime()))
+    if (!ContextualCheckBlockHeader(block, state, chainstate.m_blockman, chainparams, pindexPrev, TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime())))
         return error("%s: Consensus::ContextualCheckBlockHeader: %s", __func__, state.ToString());
     if (!CheckBlock(block, state, chainparams.GetConsensus(), fCheckPOW, fCheckMerkleRoot))
         return error("%s: Consensus::CheckBlock: %s", __func__, state.ToString());

Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ bool CGovernanceObject::ProcessVote(CMasternodeMetaMan& mn_metaman, CGovernanceM`
`120`	`120`	`LogPrint(BCLog::GOBJECT, "%s\n", msg);`
`121`	`121`	`}`
`122`	`122`
`123`		`- int64_t nNow = GetAdjustedTime();`
	`123`	`+ int64_t nNow = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());`
`124`	`124`	`int64_t nVoteTimeUpdate = voteInstanceRef.nTime;`
`125`	`125`	`if (govman.AreRateChecksEnabled()) {`
`126`	`126`	`int64_t nTimeDelta = nNow - voteInstanceRef.nTime;`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ bool CProposalValidator::ValidateStartEndEpoch(bool fCheckExpiration)`
`136`	`136`	`return false;`
`137`	`137`	`}`
`138`	`138`
`139`		`- if (fCheckExpiration && nEndEpoch <= GetAdjustedTime()) {`
	`139`	`+ if (fCheckExpiration && nEndEpoch <= TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime())) {`
`140`	`140`	`strErrorMessages += "expired;";`
`141`	`141`	`return false;`
`142`	`142`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ CGovernanceVote::CGovernanceVote(const COutPoint& outpointMasternodeIn, const ui`
`87`	`87`	`nParentHash(nParentHashIn),`
`88`	`88`	`nVoteOutcome(eVoteOutcomeIn),`
`89`	`89`	`nVoteSignal(eVoteSignalIn),`
`90`		`- nTime(GetAdjustedTime())`
	`90`	`+ nTime(TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime()))`
`91`	`91`	`{`
`92`	`92`	`UpdateHash();`
`93`	`93`	`}`
`@@ -154,8 +154,8 @@ bool CGovernanceVote::CheckSignature(const CBLSPublicKey& pubKey) const`
`154`	`154`
`155`	`155`	`bool CGovernanceVote::IsValid(const CDeterministicMNList& tip_mn_list, bool useVotingKey) const`
`156`	`156`	`{`
`157`		`- if (nTime > GetAdjustedTime() + (60 * 60)) {`
`158`		`- LogPrint(BCLog::GOBJECT, "CGovernanceVote::IsValid -- vote is too far ahead of current time - %s - nTime %lli - Max Time %lli\n", GetHash().ToString(), nTime, GetAdjustedTime() + (60 * 60));`
	`157`	`+ if (nTime > TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime() + 1h)) {`
	`158`	`+ LogPrint(BCLog::GOBJECT, "CGovernanceVote::IsValid -- vote is too far ahead of current time - %s - nTime %lli - Max Time %lli\n", GetHash().ToString(), nTime, TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime() + 1h));`
`159`	`159`	`return false;`
`160`	`160`	`}`
`161`	`161`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ void CDKGDebugManager::ResetLocalSessionStatus(Consensus::LLMQType llmqType, int`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`localStatus.sessions.erase(it);`
`157`		`- localStatus.nTime = GetAdjustedTime();`
	`157`	`+ localStatus.nTime = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`void CDKGDebugManager::InitLocalSessionStatus(const Consensus::LLMQParams& llmqParams, int quorumIndex, const uint256& quorumHash, int quorumHeight)`
`@@ -186,7 +186,7 @@ void CDKGDebugManager::UpdateLocalSessionStatus(Consensus::LLMQType llmqType, in`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`if (func(it->second)) {`
`189`		`- localStatus.nTime = GetAdjustedTime();`
	`189`	`+ localStatus.nTime = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());`
`190`	`190`	`}`
`191`	`191`	`}`
`192`	`192`
`@@ -200,7 +200,7 @@ void CDKGDebugManager::UpdateLocalMemberStatus(Consensus::LLMQType llmqType, int`
`200`	`200`	`}`
`201`	`201`
`202`	`202`	`if (func(it->second.members.at(memberIdx))) {`
`203`		`- localStatus.nTime = GetAdjustedTime();`
	`203`	`+ localStatus.nTime = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());`
`204`	`204`	`}`
`205`	`205`	`}`
`206`	`206`
Original file line number	Diff line number	Diff line change
`@@ -6025,7 +6025,7 @@ bool PeerManagerImpl::SendMessages(CNode* pto)`
`6025`	`6025`	`// Convert HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER to microseconds before scaling`
`6026`	`6026`	`// to maintain precision`
`6027`	`6027`	`std::chrono::microseconds{HEADERS_DOWNLOAD_TIMEOUT_PER_HEADER} *`
`6028`		`- Ticks<std::chrono::seconds>(GetAdjustedTime() - m_chainman.m_best_header->Time()) / consensusParams.nPowTargetSpacing`
	`6028`	`+ Ticks<std::chrono::seconds>(TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime() - m_chainman.m_best_header->Time())) / consensusParams.nPowTargetSpacing`
`6029`	`6029`	`);`
`6030`	`6030`	`nSyncStarted++;`
`6031`	`6031`	`}`