554 lines
27 KiB
C++
554 lines
27 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
||
// Copyright (c) 2009-2014 The Bitcoin Core developers
|
||
// Copyright (c) 2016-2023 The Zcash developers
|
||
// Distributed under the MIT software license, see the accompanying
|
||
// file COPYING or https://www.opensource.org/licenses/mit-license.php .
|
||
|
||
#include "validationinterface.h"
|
||
|
||
#include "chainparams.h"
|
||
#include "init.h"
|
||
#include "main.h"
|
||
#include "txmempool.h"
|
||
#include "ui_interface.h"
|
||
|
||
#include <boost/thread.hpp>
|
||
|
||
#include <chrono>
|
||
#include <thread>
|
||
|
||
#include <rust/metrics.h>
|
||
|
||
using namespace boost::placeholders;
|
||
|
||
static CMainSignals g_signals;
|
||
|
||
static constexpr const char* METRIC_WALLET_SYNCED_HEIGHT = "zcashd.wallet.synced.block.height";
|
||
|
||
CMainSignals& GetMainSignals()
|
||
{
|
||
return g_signals;
|
||
}
|
||
|
||
void RegisterValidationInterface(CValidationInterface* pwalletIn) {
|
||
g_signals.UpdatedBlockTip.connect(boost::bind(&CValidationInterface::UpdatedBlockTip, pwalletIn, _1));
|
||
g_signals.GetBatchScanner.connect(boost::bind(&CValidationInterface::GetBatchScanner, pwalletIn));
|
||
g_signals.SyncTransaction.connect(boost::bind(&CValidationInterface::SyncTransaction, pwalletIn, _1, _2, _3));
|
||
g_signals.EraseTransaction.connect(boost::bind(&CValidationInterface::EraseFromWallet, pwalletIn, _1));
|
||
g_signals.UpdatedTransaction.connect(boost::bind(&CValidationInterface::UpdatedTransaction, pwalletIn, _1));
|
||
g_signals.ChainTip.connect(boost::bind(&CValidationInterface::ChainTip, pwalletIn, _1, _2, _3));
|
||
g_signals.Broadcast.connect(boost::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn, _1));
|
||
g_signals.BlockChecked.connect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, _1, _2));
|
||
g_signals.AddressForMining.connect(boost::bind(&CValidationInterface::GetAddressForMining, pwalletIn, _1));
|
||
}
|
||
|
||
void UnregisterValidationInterface(CValidationInterface* pwalletIn) {
|
||
g_signals.AddressForMining.disconnect(boost::bind(&CValidationInterface::GetAddressForMining, pwalletIn, _1));
|
||
g_signals.BlockChecked.disconnect(boost::bind(&CValidationInterface::BlockChecked, pwalletIn, _1, _2));
|
||
g_signals.Broadcast.disconnect(boost::bind(&CValidationInterface::ResendWalletTransactions, pwalletIn, _1));
|
||
g_signals.ChainTip.disconnect(boost::bind(&CValidationInterface::ChainTip, pwalletIn, _1, _2, _3));
|
||
g_signals.UpdatedTransaction.disconnect(boost::bind(&CValidationInterface::UpdatedTransaction, pwalletIn, _1));
|
||
g_signals.EraseTransaction.disconnect(boost::bind(&CValidationInterface::EraseFromWallet, pwalletIn, _1));
|
||
g_signals.SyncTransaction.disconnect(boost::bind(&CValidationInterface::SyncTransaction, pwalletIn, _1, _2, _3));
|
||
g_signals.GetBatchScanner.disconnect(boost::bind(&CValidationInterface::GetBatchScanner, pwalletIn));
|
||
g_signals.UpdatedBlockTip.disconnect(boost::bind(&CValidationInterface::UpdatedBlockTip, pwalletIn, _1));
|
||
}
|
||
|
||
void UnregisterAllValidationInterfaces() {
|
||
g_signals.AddressForMining.disconnect_all_slots();
|
||
g_signals.BlockChecked.disconnect_all_slots();
|
||
g_signals.Broadcast.disconnect_all_slots();
|
||
g_signals.ChainTip.disconnect_all_slots();
|
||
g_signals.UpdatedTransaction.disconnect_all_slots();
|
||
g_signals.EraseTransaction.disconnect_all_slots();
|
||
g_signals.SyncTransaction.disconnect_all_slots();
|
||
g_signals.GetBatchScanner.disconnect_all_slots();
|
||
g_signals.UpdatedBlockTip.disconnect_all_slots();
|
||
}
|
||
|
||
void AddTxToBatches(
|
||
std::vector<BatchScanner*> &batchScanners,
|
||
const CTransaction &tx,
|
||
const uint256 &blockTag,
|
||
const int nHeight)
|
||
{
|
||
CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
|
||
ssTx << tx;
|
||
std::vector<unsigned char> txBytes(ssTx.begin(), ssTx.end());
|
||
for (auto& batchScanner : batchScanners) {
|
||
batchScanner->AddTransaction(tx, txBytes, blockTag, nHeight);
|
||
}
|
||
}
|
||
|
||
void FlushBatches(std::vector<BatchScanner*> &batchScanners) {
|
||
for (auto& batchScanner : batchScanners) {
|
||
batchScanner->Flush();
|
||
}
|
||
}
|
||
|
||
void SyncWithWallets(
|
||
std::vector<BatchScanner*> &batchScanners,
|
||
const CTransaction &tx,
|
||
const CBlock *pblock,
|
||
const int nHeight)
|
||
{
|
||
for (auto& batchScanner : batchScanners) {
|
||
batchScanner->SyncTransaction(tx, pblock, nHeight);
|
||
}
|
||
g_signals.SyncTransaction(tx, pblock, nHeight);
|
||
}
|
||
|
||
struct CachedBlockData {
|
||
CBlockIndex *pindex;
|
||
MerkleFrontiers oldTrees;
|
||
std::list<CTransaction> txConflicted;
|
||
|
||
CachedBlockData(
|
||
CBlockIndex *pindex,
|
||
MerkleFrontiers oldTrees,
|
||
std::list<CTransaction> txConflicted):
|
||
pindex(pindex), oldTrees(oldTrees), txConflicted(txConflicted) {}
|
||
};
|
||
|
||
void ThreadNotifyWallets(CBlockIndex *pindexLastTip)
|
||
{
|
||
// If pindexLastTip == nullptr, the wallet is at genesis.
|
||
// However, the genesis block is not loaded synchronously.
|
||
// We need to wait for ThreadImport to finish.
|
||
while (pindexLastTip == nullptr) {
|
||
{
|
||
LOCK(cs_main);
|
||
pindexLastTip = chainActive.Genesis();
|
||
}
|
||
MilliSleep(50);
|
||
}
|
||
|
||
while (true) {
|
||
// Run the notifier on an integer second in the steady clock.
|
||
auto now = std::chrono::steady_clock::now().time_since_epoch();
|
||
auto nextFire = std::chrono::duration_cast<std::chrono::seconds>(
|
||
now + std::chrono::seconds(1));
|
||
std::this_thread::sleep_until(
|
||
std::chrono::time_point<std::chrono::steady_clock>(nextFire));
|
||
|
||
boost::this_thread::interruption_point();
|
||
|
||
auto chainParams = Params();
|
||
|
||
//
|
||
// Collect all the state we require
|
||
//
|
||
|
||
// The common ancestor between the last chain tip we notified and the
|
||
// current chain tip.
|
||
const CBlockIndex *pindexFork;
|
||
// The stack of blocks we will notify as having been connected.
|
||
// Pushed in reverse, popped in order.
|
||
std::vector<CachedBlockData> blockStack;
|
||
// Sequence number indicating that we have notified wallets of transactions up to
|
||
// the ConnectBlock() call that generated this sequence number.
|
||
std::optional<uint64_t> chainNotifiedSequence;
|
||
// Transactions that have been recently added to the mempool.
|
||
std::pair<std::vector<CTransaction>, uint64_t> recentlyAdded;
|
||
|
||
{
|
||
LOCK(cs_main);
|
||
|
||
// Figure out the path from the last block we notified to the
|
||
// current chain tip.
|
||
CBlockIndex *pindex = chainActive.Tip();
|
||
pindexFork = chainActive.FindFork(pindexLastTip);
|
||
|
||
// Iterate backwards over the connected blocks until we have at
|
||
// most WALLET_NOTIFY_MAX_BLOCKS to process.
|
||
while (pindex && pindex->nHeight > pindexFork->nHeight + WALLET_NOTIFY_MAX_BLOCKS) {
|
||
pindex = pindex->pprev;
|
||
}
|
||
|
||
// Iterate backwards over the connected blocks we need to notify.
|
||
bool originalTipAtFork = pindex && pindex == pindexFork;
|
||
while (pindex && pindex != pindexFork) {
|
||
MerkleFrontiers oldFrontiers;
|
||
// Get the Sprout commitment tree as of the start of this block.
|
||
assert(pcoinsTip->GetSproutAnchorAt(pindex->hashSproutAnchor, oldFrontiers.sprout));
|
||
|
||
// Get the Sapling commitment tree as of the start of this block.
|
||
// We can get this from the `hashFinalSaplingRoot` of the last block
|
||
// However, this is only reliable if the last block was on or after
|
||
// the Sapling activation height. Otherwise, the last anchor was the
|
||
// empty root.
|
||
if (chainParams.GetConsensus().NetworkUpgradeActive(
|
||
pindex->pprev->nHeight, Consensus::UPGRADE_SAPLING)) {
|
||
assert(pcoinsTip->GetSaplingAnchorAt(
|
||
pindex->pprev->hashFinalSaplingRoot, oldFrontiers.sapling));
|
||
} else {
|
||
assert(pcoinsTip->GetSaplingAnchorAt(SaplingMerkleTree::empty_root(), oldFrontiers.sapling));
|
||
}
|
||
|
||
// Get the Orchard Merkle frontier as of the start of this block.
|
||
// We can get this from the `hashFinalOrchardRoot` of the last block
|
||
// However, this is only reliable if the last block was on or after
|
||
// the Orchard activation height. Otherwise, the last anchor was the
|
||
// empty root.
|
||
if (chainParams.GetConsensus().NetworkUpgradeActive(
|
||
pindex->pprev->nHeight, Consensus::UPGRADE_NU5)) {
|
||
assert(pcoinsTip->GetOrchardAnchorAt(
|
||
pindex->pprev->hashFinalOrchardRoot, oldFrontiers.orchard));
|
||
} else {
|
||
assert(pcoinsTip->GetOrchardAnchorAt(
|
||
OrchardMerkleFrontier::empty_root(), oldFrontiers.orchard));
|
||
}
|
||
|
||
// Fetch recently-conflicted transactions. These will include any
|
||
// block that has been connected since the last cycle, but we only
|
||
// notify for the conflicts created by the current active chain.
|
||
auto recentlyConflicted = TakeRecentlyConflicted(pindex);
|
||
|
||
blockStack.emplace_back(
|
||
pindex,
|
||
oldFrontiers,
|
||
recentlyConflicted.first);
|
||
|
||
chainNotifiedSequence = recentlyConflicted.second;
|
||
|
||
pindex = pindex->pprev;
|
||
}
|
||
|
||
// This conditional can be true in the case that in the interval
|
||
// since the last second-boundary, two reorgs occurred: one that
|
||
// shifted over to a different chain history, and then a second
|
||
// that returned the chain to the original pre-reorg tip. This
|
||
// should never occur unless a caller has manually used
|
||
// `invalidateblock` to force the second reorg or we have a long
|
||
// persistent set of dueling chains. In such a case, wallets may
|
||
// not be fully notified of conflicted transactions, but they will
|
||
// still have a correct view of the current main chain, and they
|
||
// will still be notified properly of the current state of
|
||
// transactions in the mempool.
|
||
if (originalTipAtFork) {
|
||
chainNotifiedSequence = GetChainConnectedSequence();
|
||
}
|
||
if (chainNotifiedSequence.has_value()) {
|
||
recentlyAdded = mempool.DrainRecentlyAdded();
|
||
}
|
||
}
|
||
|
||
//
|
||
// Execute wallet logic based on the collected state. We MUST NOT take
|
||
// the cs_main or mempool.cs locks again until after the next sleep;
|
||
// doing so introduces a locking side-channel between this code and the
|
||
// network message processing thread.
|
||
//
|
||
|
||
// The wallet inherited from Bitcoin Core was built around the following
|
||
// general workflow for moving from one chain tip to another:
|
||
//
|
||
// - For each block in the old chain, from its tip to the fork point:
|
||
// - For each transaction in the block:
|
||
// - 1️⃣ Trial-decrypt the transaction's shielded outputs.
|
||
// - If the transaction belongs to the wallet:
|
||
// - 2️⃣ Add or update the transaction, and mark it as dirty.
|
||
// - Update the wallet's view of the chain tip.
|
||
// - 3️⃣ In `zcashd`, this is when we decrement note witnesses.
|
||
// - For each block in the new chain, from the fork point to its tip:
|
||
// - For each transaction that became conflicted by this block:
|
||
// - 4️⃣ Trial-decrypt the transaction's shielded outputs.
|
||
// - If the transaction belongs to the wallet:
|
||
// - 5️⃣ Add or update the transaction, and mark it as dirty.
|
||
// - For each transaction in the block:
|
||
// - 6️⃣ Trial-decrypt the transaction's shielded outputs.
|
||
// - If the transaction belongs to the wallet:
|
||
// - 7️⃣ Add or update the transaction, and mark it as dirty.
|
||
// - Update the wallet's view of the chain tip.
|
||
// - 8️⃣ In `zcashd`, this is when we increment note witnesses.
|
||
// - For each transaction in the mempool:
|
||
// - 9️⃣ Trial-decrypt the transaction's shielded outputs.
|
||
// - If the transaction belongs to the wallet:
|
||
// - 🅰️ Add or update the transaction, and mark it as dirty.
|
||
//
|
||
// Steps 2️⃣, 3️⃣, 5️⃣, 7️⃣, 8️⃣, and 🅰️ are where wallet state is updated,
|
||
// and the relative order of these updates must be preserved in order to
|
||
// avoid breaking any internal assumptions that the wallet makes.
|
||
//
|
||
// Steps 1️⃣, 4️⃣, 6️⃣, and 9️⃣ can be performed at any time, as long as
|
||
// their results are available when their respective conditionals are
|
||
// evaluated. We therefore refactor the above workflow to enable the
|
||
// trial-decryption work to be batched and parallelised:
|
||
//
|
||
// - For each block in the old chain, from its tip to the fork point:
|
||
// - For each transaction in the block:
|
||
// - Accumulate its Sprout, Sapling, and Orchard outputs.
|
||
// - For each block in the new chain, from the fork point to its tip:
|
||
// - For each transaction that became conflicted by this block:
|
||
// - Accumulate its Sprout, Sapling, and Orchard outputs.
|
||
// - For each transaction in the block:
|
||
// - Accumulate its Sprout, Sapling, and Orchard outputs.
|
||
//
|
||
// - 1️⃣4️⃣6️⃣9️⃣ Trial-decrypt the Sprout, Sapling, and Orchard outputs.
|
||
// - This can split up and batch the work however is most efficient.
|
||
//
|
||
// - For each block in the old chain, from its tip to the fork point:
|
||
// - For each transaction in the block:
|
||
// - If the transaction has decrypted outputs, or transparent inputs
|
||
// that belong to the wallet:
|
||
// - 2️⃣ Add or update the transaction, and mark it as dirty.
|
||
// - Update the wallet's view of the chain tip.
|
||
// - 3️⃣ In `zcashd`, this is when we decrement note witnesses.
|
||
// - For each block in the new chain, from the fork point to its tip:
|
||
// - For each transaction that became conflicted by this block:
|
||
// - If the transaction has decrypted outputs, or transparent inputs
|
||
// that belong to the wallet:
|
||
// - 5️⃣ Add or update the transaction, and mark it as dirty.
|
||
// - For each transaction in the block:
|
||
// - If the transaction has decrypted outputs, or transparent inputs
|
||
// that belong to the wallet:
|
||
// - 7️⃣ Add or update the transaction, and mark it as dirty.
|
||
// - Update the wallet's view of the chain tip.
|
||
// - 8️⃣ In `zcashd`, this is when we increment note witnesses.
|
||
// - For each transaction in the mempool:
|
||
// - If the transaction has decrypted outputs, or transparent inputs
|
||
// that belong to the wallet:
|
||
// - 🅰️ Add or update the transaction, and mark it as dirty.
|
||
|
||
// Get a new handle to the BatchScanner for each listener in each loop.
|
||
// This allows the listeners to alter their scanning logic over time,
|
||
// for example to add new incoming viewing keys.
|
||
auto batchScanners = GetMainSignals().GetBatchScanner();
|
||
|
||
// Closure that will add a block from blockStack to batchScanners.
|
||
auto batchScanConnectedBlock = [&](const CachedBlockData& blockData) {
|
||
// Read block from disk.
|
||
CBlock block;
|
||
if (!ReadBlockFromDisk(block, blockData.pindex, chainParams.GetConsensus())) {
|
||
LogPrintf(
|
||
"*** %s: Failed to read block %s while collecting shielded outputs from block connects",
|
||
__func__, blockData.pindex->GetBlockHash().GetHex());
|
||
uiInterface.ThreadSafeMessageBox(
|
||
strprintf(_("Error: A fatal internal error occurred, see %s for details"), GetDebugLogPath()),
|
||
"", CClientUIInterface::MSG_ERROR);
|
||
StartShutdown();
|
||
return;
|
||
}
|
||
|
||
// Batch transactions that went from mempool to conflicted:
|
||
for (const CTransaction &tx : blockData.txConflicted) {
|
||
AddTxToBatches(
|
||
batchScanners,
|
||
tx,
|
||
blockData.pindex->GetBlockHash(),
|
||
blockData.pindex->nHeight + 1);
|
||
}
|
||
// ... and transactions that got confirmed:
|
||
for (const CTransaction &tx : block.vtx) {
|
||
AddTxToBatches(
|
||
batchScanners,
|
||
tx,
|
||
blockData.pindex->GetBlockHash(),
|
||
blockData.pindex->nHeight);
|
||
}
|
||
};
|
||
|
||
// Store the iterator pointing to the next block in blockStack that
|
||
// should be added to the batch scanners. This will always be valid,
|
||
// because:
|
||
// - blockStack is only mutated via std::vector::pop_back() below this
|
||
// point, which only invalidates std::vector::end() and iterators to
|
||
// the last element of the vector.
|
||
// - We check below that blockStack.rbegin() != blockStackScanned before
|
||
// any call to blockStack.pop_back(), which ensures that we never pop
|
||
// the block that blockStackScanned is pointing to.
|
||
auto blockStackScanned = blockStack.rbegin();
|
||
|
||
if (!batchScanners.empty()) {
|
||
// Batch the shielded outputs across all blocks being processed.
|
||
// TODO: We can probably not bother trial-decrypting transactions
|
||
// in blocks being disconnected, or that are becoming conflicted,
|
||
// instead doing a plain "is this tx in the wallet" check. However,
|
||
// the logic in AddToWalletIfInvolvingMe would need to be carefully
|
||
// checked to ensure its side-effects are correctly preserved, so
|
||
// for now we maintain the previous behaviour of trial-decrypting
|
||
// everything.
|
||
|
||
// Batch block disconnects. We always add every disconnected block
|
||
// to batchScanners, because this will be at most 100 blocks, which
|
||
// is at most 2GB, but in practice will be much less than this, and
|
||
// the growth problem in the interaction between this thread and the
|
||
// main node is in connected blocks. And per the above TODO, this
|
||
// might eventually be removed entirely.
|
||
auto pindexScan = pindexLastTip;
|
||
while (pindexScan && pindexScan != pindexFork) {
|
||
// Read block from disk.
|
||
CBlock block;
|
||
if (!ReadBlockFromDisk(block, pindexScan, chainParams.GetConsensus())) {
|
||
LogPrintf(
|
||
"*** %s: Failed to read block %s while collecting shielded outputs",
|
||
__func__, pindexScan->GetBlockHash().GetHex());
|
||
uiInterface.ThreadSafeMessageBox(
|
||
strprintf(_("Error: A fatal internal error occurred, see %s for details"), GetDebugLogPath()),
|
||
"", CClientUIInterface::MSG_ERROR);
|
||
StartShutdown();
|
||
return;
|
||
}
|
||
|
||
// Batch transactions that went from 1-confirmed to 0-confirmed
|
||
// or conflicted.
|
||
for (const CTransaction &tx : block.vtx) {
|
||
AddTxToBatches(batchScanners, tx, block.GetHash(), pindexScan->nHeight);
|
||
}
|
||
|
||
// On to the next block!
|
||
pindexScan = pindexScan->pprev;
|
||
}
|
||
|
||
// Add block connections to batchScanners until we have either added
|
||
// the entirety of blockStack, or have reached the memory limit.
|
||
//
|
||
// We process blockStack in the same order we do below, so batched
|
||
// work can be completed in roughly the order we need it.
|
||
for (; blockStackScanned != blockStack.rend(); ++blockStackScanned) {
|
||
const auto& blockData = *blockStackScanned;
|
||
batchScanConnectedBlock(blockData);
|
||
}
|
||
|
||
// Batch transactions in the mempool. It's fine that we always add
|
||
// these to batchScanners; if we reached the memory limit earlier,
|
||
// it just means that the mempool results will be completed earlier
|
||
// than they are required, and will sit in memory for a bit longer.
|
||
// The ZIP 401 mempool limits are around 80MB, which is well below
|
||
// the limits we are concerned with here.
|
||
for (auto& tx : recentlyAdded.first) {
|
||
AddTxToBatches(batchScanners, tx, uint256(), pindexLastTip->nHeight + 1);
|
||
}
|
||
}
|
||
|
||
// Ensure that all pending work has been started.
|
||
FlushBatches(batchScanners);
|
||
|
||
// Notify block disconnects
|
||
while (pindexLastTip && pindexLastTip != pindexFork) {
|
||
// Read block from disk.
|
||
CBlock block;
|
||
if (!ReadBlockFromDisk(block, pindexLastTip, chainParams.GetConsensus())) {
|
||
LogPrintf(
|
||
"*** %s: Failed to read block %s while notifying wallets of block disconnects",
|
||
__func__, pindexLastTip->GetBlockHash().GetHex());
|
||
uiInterface.ThreadSafeMessageBox(
|
||
strprintf(_("Error: A fatal internal error occurred, see %s for details"), GetDebugLogPath()),
|
||
"", CClientUIInterface::MSG_ERROR);
|
||
StartShutdown();
|
||
return;
|
||
}
|
||
|
||
// Let wallets know transactions went from 1-confirmed to
|
||
// 0-confirmed or conflicted:
|
||
for (const CTransaction &tx : block.vtx) {
|
||
SyncWithWallets(batchScanners, tx, NULL, pindexLastTip->nHeight);
|
||
}
|
||
// Update cached incremental witnesses
|
||
// This will take the cs_main lock in order to obtain the CBlockLocator
|
||
// used by `SetBestChain`, but as that write only occurs once every
|
||
// WRITE_WITNESS_INTERVAL * 1000000 microseconds this should not be
|
||
// exploitable as a timing channel.
|
||
GetMainSignals().ChainTip(pindexLastTip, &block, std::nullopt);
|
||
|
||
// On to the next block!
|
||
pindexLastTip = pindexLastTip->pprev;
|
||
MetricsGauge(METRIC_WALLET_SYNCED_HEIGHT, pindexLastTip->nHeight);
|
||
}
|
||
|
||
// Notify block connections
|
||
while (!blockStack.empty()) {
|
||
// Add more block connections to batchScanners until we have either
|
||
// added the rest of blockStack, or have reached the memory limit
|
||
// again. At this point, we know that blockStackScanned has not been
|
||
// invalidated by mutations to blockStack, and can be dereferenced.
|
||
for (; blockStackScanned != blockStack.rend(); ++blockStackScanned) {
|
||
const auto& blockData = *blockStackScanned;
|
||
batchScanConnectedBlock(blockData);
|
||
}
|
||
|
||
// Ensure that all pending work has been started.
|
||
FlushBatches(batchScanners);
|
||
|
||
// Sync with the wallet until either:
|
||
// - there are no more blocks to sync, and we are done;
|
||
// - we have synced every block that batchScanners has been given,
|
||
// and can make no more forward progress; or
|
||
// - we have more blocks that we _could_ add to batchScanners, and
|
||
// are back below the memory limit (so should create more batches
|
||
// before continuing, for optimal pipelining).
|
||
while (!(
|
||
blockStack.empty() ||
|
||
blockStack.rbegin() == blockStackScanned ||
|
||
(blockStackScanned != blockStack.rend())
|
||
)) {
|
||
auto& blockData = blockStack.back();
|
||
|
||
// Read block from disk.
|
||
CBlock block;
|
||
if (!ReadBlockFromDisk(block, blockData.pindex, chainParams.GetConsensus())) {
|
||
LogPrintf(
|
||
"*** %s: Failed to read block %s while notifying wallets of block connects",
|
||
__func__, blockData.pindex->GetBlockHash().GetHex());
|
||
uiInterface.ThreadSafeMessageBox(
|
||
strprintf(_("Error: A fatal internal error occurred, see %s for details"), GetDebugLogPath()),
|
||
"", CClientUIInterface::MSG_ERROR);
|
||
StartShutdown();
|
||
return;
|
||
}
|
||
|
||
// Tell wallet about transactions that went from mempool
|
||
// to conflicted:
|
||
for (const CTransaction &tx : blockData.txConflicted) {
|
||
SyncWithWallets(batchScanners, tx, NULL, blockData.pindex->nHeight + 1);
|
||
}
|
||
// ... and about transactions that got confirmed:
|
||
for (const CTransaction &tx : block.vtx) {
|
||
SyncWithWallets(batchScanners, tx, &block, blockData.pindex->nHeight);
|
||
}
|
||
// Update cached incremental witnesses
|
||
// This will take the cs_main lock in order to obtain the CBlockLocator
|
||
// used by `SetBestChain`, but as that write only occurs once every
|
||
// WRITE_WITNESS_INTERVAL * 1000000 microseconds this should not be
|
||
// exploitable as a timing channel.
|
||
GetMainSignals().ChainTip(blockData.pindex, &block, blockData.oldTrees);
|
||
|
||
// Notify UI to display prev block's coinbase if it was ours.
|
||
static uint256 hashPrevBestCoinBase;
|
||
GetMainSignals().UpdatedTransaction(hashPrevBestCoinBase);
|
||
hashPrevBestCoinBase = block.vtx[0].GetHash();
|
||
|
||
// This block is done!
|
||
pindexLastTip = blockData.pindex;
|
||
MetricsGauge(METRIC_WALLET_SYNCED_HEIGHT, pindexLastTip->nHeight);
|
||
assert(blockStack.rbegin() != blockStackScanned);
|
||
blockStack.pop_back();
|
||
}
|
||
}
|
||
|
||
// Notify transactions in the mempool
|
||
for (auto& tx : recentlyAdded.first) {
|
||
try {
|
||
SyncWithWallets(batchScanners, tx, NULL, pindexLastTip->nHeight + 1);
|
||
} catch (const boost::thread_interrupted&) {
|
||
throw;
|
||
} catch (const std::exception& e) {
|
||
PrintExceptionContinue(&e, "ThreadNotifyWallets()");
|
||
} catch (...) {
|
||
PrintExceptionContinue(NULL, "ThreadNotifyWallets()");
|
||
}
|
||
}
|
||
|
||
// Update the notified sequence numbers. We only need this in regtest mode,
|
||
// and should not lock on cs or cs_main here otherwise.
|
||
if (chainParams.NetworkIDString() == "regtest") {
|
||
if (chainNotifiedSequence.has_value()) {
|
||
SetChainNotifiedSequence(chainParams, chainNotifiedSequence.value());
|
||
}
|
||
if (recentlyAdded.second > 0) {
|
||
mempool.SetNotifiedSequence(recentlyAdded.second);
|
||
}
|
||
}
|
||
}
|
||
}
|