+ kernel/disconnected_transactions.h \

+ bench/disconnected_transactions.cpp \

+ test/fuzz/package_eval.cpp \

+ SerializeFileDB("anchors", anchors_db_path, CAddress::V2_DISK(anchors));

+ DeserializeFileDB(anchors_db_path, CAddress::V2_DISK(anchors));

+ if (!pubKey.IsValid()) {

+ addressRet = CNoDestination(scriptPubKey);

+ } else {

+ addressRet = PubKeyDestination(pubKey);

+ }

+ return false;

+ addressRet = WitnessUnknown{vSolutions[0][0], vSolutions[1]};

+ addressRet = CNoDestination(scriptPubKey);

+ return dest.GetScript();

+ }

+

+ CScript operator()(const PubKeyDestination& dest) const

+ {

+ return CScript() << ToByteVector(dest.GetPubKey()) << OP_CHECKSIG;

+ return CScript() << CScript::EncodeOP_N(id.GetWitnessVersion()) << id.GetWitnessProgram();

+

+class ValidDestinationVisitor

+{

+public:

+ bool operator()(const CNoDestination& dest) const { return false; }

+ bool operator()(const PubKeyDestination& dest) const { return false; }

+ bool operator()(const PKHash& dest) const { return true; }

+ bool operator()(const ScriptHash& dest) const { return true; }

+ bool operator()(const WitnessV0KeyHash& dest) const { return true; }

+ bool operator()(const WitnessV0ScriptHash& dest) const { return true; }

+ bool operator()(const WitnessV1Taproot& dest) const { return true; }

+ bool operator()(const WitnessUnknown& dest) const { return true; }

+};

+ return std::visit(ValidDestinationVisitor(), dest);

+private:

+ CScript m_script;

+

+public:

+ CNoDestination() = default;

+ CNoDestination(const CScript& script) : m_script(script) {}

+

+ const CScript& GetScript() const { return m_script; }

+

+ friend bool operator==(const CNoDestination& a, const CNoDestination& b) { return a.GetScript() == b.GetScript(); }

+ friend bool operator<(const CNoDestination& a, const CNoDestination& b) { return a.GetScript() < b.GetScript(); }

+};

+

+struct PubKeyDestination {

+private:

+ CPubKey m_pubkey;

+

+ PubKeyDestination(const CPubKey& pubkey) : m_pubkey(pubkey) {}

+

+ const CPubKey& GetPubKey() const LIFETIMEBOUND { return m_pubkey; }

+

+ friend bool operator==(const PubKeyDestination& a, const PubKeyDestination& b) { return a.GetPubKey() == b.GetPubKey(); }

+ friend bool operator<(const PubKeyDestination& a, const PubKeyDestination& b) { return a.GetPubKey() < b.GetPubKey(); }

+private:

+ unsigned int m_version;

+ std::vector<unsigned char> m_program;

+

+public:

+ WitnessUnknown(unsigned int version, const std::vector<unsigned char>& program) : m_version(version), m_program(program) {}

+ WitnessUnknown(int version, const std::vector<unsigned char>& program) : m_version(static_cast<unsigned int>(version)), m_program(program) {}

+

+ unsigned int GetWitnessVersion() const { return m_version; }

+ const std::vector<unsigned char>& GetWitnessProgram() const LIFETIMEBOUND { return m_program; }

+ if (w1.GetWitnessVersion() != w2.GetWitnessVersion()) return false;

+ return w1.GetWitnessProgram() == w2.GetWitnessProgram();

+ if (w1.GetWitnessVersion() < w2.GetWitnessVersion()) return true;

+ if (w1.GetWitnessVersion() > w2.GetWitnessVersion()) return false;

+ return w1.GetWitnessProgram() < w2.GetWitnessProgram();

+ * A txout script categorized into standard templates.

+ * * CNoDestination: Optionally a script, no corresponding address.

+ * * PubKeyDestination: TxoutType::PUBKEY (P2PK), no corresponding address

+ * * PKHash: TxoutType::PUBKEYHASH destination (P2PKH address)

+ * * ScriptHash: TxoutType::SCRIPTHASH destination (P2SH address)

+ * * WitnessV0ScriptHash: TxoutType::WITNESS_V0_SCRIPTHASH destination (P2WSH address)

+ * * WitnessV0KeyHash: TxoutType::WITNESS_V0_KEYHASH destination (P2WPKH address)

+ * * WitnessV1Taproot: TxoutType::WITNESS_V1_TAPROOT destination (P2TR address)

+ * * WitnessUnknown: TxoutType::WITNESS_UNKNOWN destination (P2W??? address)

+using CTxDestination = std::variant<CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown>;

+/** Check whether a CTxDestination corresponds to one with an address. */

+ * Parse a scriptPubKey for the destination.

+ *

+ * For standard scripts that have addresses (and P2PK as an exception), a corresponding CTxDestination

+ * is assigned to addressRet.

+ * For all other scripts. addressRet is assigned as a CNoDestination containing the scriptPubKey.

+ *

+ * Returns true for standard destinations with addresses - P2PKH, P2SH, P2WPKH, P2WSH, P2TR and P2W??? scripts.

+ * Returns false for non-standard destinations and those without addresses - P2PK, bare multisig, null data, and nonstandard scripts.

+ auto result = AttemptSelection(wallet.chain(), 1003 * COIN, group, coin_selection_params, /*allow_mixed_output_types=*/true);

+// Copyright (c) 2023 The Bitcoin Core developers

+// Distributed under the MIT software license, see the accompanying

+// file COPYING or http://www.opensource.org/licenses/mit-license.php.

+

+#include <bench/bench.h>

+#include <kernel/disconnected_transactions.h>

+#include <primitives/block.h>

+#include <test/util/random.h>

+#include <test/util/setup_common.h>

+

+constexpr size_t BLOCK_VTX_COUNT{4000};

+constexpr size_t BLOCK_VTX_COUNT_10PERCENT{400};

+

+using BlockTxns = decltype(CBlock::vtx);

+

+/** Reorg where 1 block is disconnected and 2 blocks are connected. */

+struct ReorgTxns {

+ /** Disconnected block. */

+ BlockTxns disconnected_txns;

+ /** First connected block. */

+ BlockTxns connected_txns_1;

+ /** Second connected block, new chain tip. Has no overlap with disconnected_txns. */

+ BlockTxns connected_txns_2;

+ /** Transactions shared between disconnected_txns and connected_txns_1. */

+ size_t num_shared;

+};

+

+static BlockTxns CreateRandomTransactions(size_t num_txns)

+{

+ // Ensure every transaction has a different txid by having each one spend the previous one.

+ static uint256 prevout_hash{uint256::ZERO};

+

+ BlockTxns txns;

+ txns.reserve(num_txns);

+ // Simplest spk for every tx

+ CScript spk = CScript() << OP_TRUE;

+ for (uint32_t i = 0; i < num_txns; ++i) {

+ CMutableTransaction tx;

+ tx.vin.emplace_back(CTxIn{COutPoint{prevout_hash, 0}});

+ tx.vout.emplace_back(CTxOut{CENT, spk});

+ auto ptx{MakeTransactionRef(tx)};

+ txns.emplace_back(ptx);

+ prevout_hash = ptx->GetHash();

+ }

+ return txns;

+}

+

+/** Creates blocks for a Reorg, each with BLOCK_VTX_COUNT transactions. Between the disconnected

+ * block and the first connected block, there will be num_not_shared transactions that are

+ * different, and all other transactions the exact same. The second connected block has all unique

+ * transactions. This is to simulate a reorg in which all but num_not_shared transactions are

+ * confirmed in the new chain. */

+static ReorgTxns CreateBlocks(size_t num_not_shared)

+{

+ auto num_shared{BLOCK_VTX_COUNT - num_not_shared};

+ const auto shared_txns{CreateRandomTransactions(/*num_txns=*/num_shared)};

+

+ // Create different sets of transactions...

+ auto disconnected_block_txns{CreateRandomTransactions(/*num_txns=*/num_not_shared)};

+ std::copy(shared_txns.begin(), shared_txns.end(), std::back_inserter(disconnected_block_txns));

+

+ auto connected_block_txns{CreateRandomTransactions(/*num_txns=*/num_not_shared)};

+ std::copy(shared_txns.begin(), shared_txns.end(), std::back_inserter(connected_block_txns));

+

+ assert(disconnected_block_txns.size() == BLOCK_VTX_COUNT);

+ assert(connected_block_txns.size() == BLOCK_VTX_COUNT);

+

+ return ReorgTxns{/*disconnected_txns=*/disconnected_block_txns,

+ /*connected_txns_1=*/connected_block_txns,

+ /*connected_txns_2=*/CreateRandomTransactions(BLOCK_VTX_COUNT),

+ /*num_shared=*/num_shared};

+}

+

+static void Reorg(const ReorgTxns& reorg)

+{

+ DisconnectedBlockTransactions disconnectpool{MAX_DISCONNECTED_TX_POOL_SIZE * 1000};

+ // Disconnect block

+ const auto evicted = disconnectpool.AddTransactionsFromBlock(reorg.disconnected_txns);

+ assert(evicted.empty());

+

+ // Connect first block

+ disconnectpool.removeForBlock(reorg.connected_txns_1);

+ // Connect new tip

+ disconnectpool.removeForBlock(reorg.connected_txns_2);

+

+ // Sanity Check

+ assert(disconnectpool.size() == BLOCK_VTX_COUNT - reorg.num_shared);

+

+ disconnectpool.clear();

+}

+

+/** Add transactions from DisconnectedBlockTransactions, remove all but one (the disconnected

+ * block's coinbase transaction) of them, and then pop from the front until empty. This is a reorg

+ * in which all of the non-coinbase transactions in the disconnected chain also exist in the new

+ * chain. */

+static void AddAndRemoveDisconnectedBlockTransactionsAll(benchmark::Bench& bench)

+{

+ const auto chains{CreateBlocks(/*num_not_shared=*/1)};

+ assert(chains.num_shared == BLOCK_VTX_COUNT - 1);

+

+ bench.minEpochIterations(10).run([&]() {

+ Reorg(chains);

+ });

+}

+

+/** Add transactions from DisconnectedBlockTransactions, remove 90% of them, and then pop from the front until empty. */

+static void AddAndRemoveDisconnectedBlockTransactions90(benchmark::Bench& bench)

+{

+ const auto chains{CreateBlocks(/*num_not_shared=*/BLOCK_VTX_COUNT_10PERCENT)};

+ assert(chains.num_shared == BLOCK_VTX_COUNT - BLOCK_VTX_COUNT_10PERCENT);

+

+ bench.minEpochIterations(10).run([&]() {

+ Reorg(chains);

+ });

+}

+

+/** Add transactions from DisconnectedBlockTransactions, remove 10% of them, and then pop from the front until empty. */

+static void AddAndRemoveDisconnectedBlockTransactions10(benchmark::Bench& bench)

+{

+ const auto chains{CreateBlocks(/*num_not_shared=*/BLOCK_VTX_COUNT - BLOCK_VTX_COUNT_10PERCENT)};

+ assert(chains.num_shared == BLOCK_VTX_COUNT_10PERCENT);

+

+ bench.minEpochIterations(10).run([&]() {

+ Reorg(chains);

+ });

+}

+

+BENCHMARK(AddAndRemoveDisconnectedBlockTransactionsAll, benchmark::PriorityLevel::HIGH);

+BENCHMARK(AddAndRemoveDisconnectedBlockTransactions90, benchmark::PriorityLevel::HIGH);

+BENCHMARK(AddAndRemoveDisconnectedBlockTransactions10, benchmark::PriorityLevel::HIGH);

+#include <clientversion.h>

+ CAutoFile file{fsbridge::fopen(blkfile, "rb"), CLIENT_VERSION};

+#include <util/fs.h>

+

+#include <cstddef>

+#include <cstdint>

+#include <cstdio>

+ CAutoFile file{fsbridge::fopen("streams_tmp", "w+b"), 0};

+ file << data;

+ std::rewind(file.Get());

+ BufferedFile bf{file, /*nBufSize=*/file_size + 1, /*nRewindIn=*/file_size};

+ file.fclose();

+ wallet.blockConnected(ChainstateRole::NORMAL, kernel::MakeBlockInfo(pindex, &block));

+ SpanReader stream{GCS_SER_VERSION, m_encoded};

+ CVectorWriter stream(GCS_SER_VERSION, m_encoded, 0);

+ SpanReader stream{GCS_SER_VERSION, m_encoded};

+ *

+ * Note that this will be true for the snapshot base block, if one is loaded (and

+ * all subsequent assumed-valid blocks) since its nChainTx value will have been set

+ * manually based on the related AssumeutxoData entry.

+ *

+ * TODO: potentially change the name of this based on the fact above.

+ CHashWriter(int nVersionIn) : nVersion{nVersionIn} {}

+#include <util/vector.h>

+ ClearShrink(m_header_commitments);

+ ClearShrink(m_redownloaded_headers);

+ AssertLockNotHeld(cs_main);

+

+ // May need reset if index is being restarted.

+ m_interrupt.reset();

+

+ m_chainstate = WITH_LOCK(::cs_main,

+ return &m_chain->context()->chainman->GetChainstateForIndexing());

+ CChain& index_chain = m_chainstate->m_chain;

+

+ m_synced = start_block == index_chain.Tip();

+ LogPrintf("%s: m_interrupt set; exiting ThreadSync\n", GetName());

+

+void BaseIndex::BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex)

+ // Ignore events from the assumed-valid chain; we will process its blocks

+ // (sequentially) after it is fully verified by the background chainstate. This

+ // is to avoid any out-of-order indexing.

+ //

+ // TODO at some point we could parameterize whether a particular index can be

+ // built out of order, but for now just do the conservative simple thing.

+ if (role == ChainstateRole::ASSUMEDVALID) {

+ return;

+ }

+

+ // Ignore BlockConnected signals until we have fully indexed the chain.

+void BaseIndex::ChainStateFlushed(ChainstateRole role, const CBlockLocator& locator)

+ // Ignore events from the assumed-valid chain; we will process its blocks

+ // (sequentially) after it is fully verified by the background chainstate.

+ if (role == ChainstateRole::ASSUMEDVALID) {

+ return;

+ }

+

+class ChainstateManager;

+ *

+ * In the presence of multiple chainstates (i.e. if a UTXO snapshot is loaded),

+ * only the background "IBD" chainstate will be indexed to avoid building the

+ * index out of order. When the background chainstate completes validation, the

+ * index will be reinitialized and indexing will continue.

+ void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override;

+ void ChainStateFlushed(ChainstateRole role, const CBlockLocator& locator) override;

+ /// Get the name of the index for display in logs.

+ const std::string& GetName() const LIFETIMEBOUND { return m_name; }

+

+ CAutoFile file{m_chainstate->m_blockman.OpenBlockFile(postx, true)};

+ argsman.AddArg("-v2transport", strprintf("Support v2 transport (default: %u)", DEFAULT_V2_TRANSPORT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);

+ // Signal NODE_P2P_V2 if BIP324 v2 transport is enabled.

+ if (args.GetBoolArg("-v2transport", DEFAULT_V2_TRANSPORT)) {

+ nLocalServices = ServiceFlags(nLocalServices | NODE_P2P_V2);

+ }

+

+ // This is defined and set here instead of inline in validation.h to avoid a hard

+ // dependency between validation and index/base, since the latter is not in

+ // libbitcoinkernel.

+ chainman.restart_indexes = [&node]() {

+ LogPrintf("[snapshot] restarting indexes\n");

+

+ // Drain the validation interface queue to ensure that the old indexes

+ // don't have any pending work.

+ SyncWithValidationInterfaceQueue();

+

+ for (auto* index : node.indexes) {

+ index->Interrupt();

+ index->Stop();

+ if (!(index->Init() && index->StartBackgroundSync())) {

+ LogPrintf("[snapshot] WARNING failed to restart index %s on snapshot chain\n", index->GetName());

+ }

+ }

+ };

+

+ const Chainstate& chainstate = WITH_LOCK(::cs_main, return chainman.GetChainstateForIndexing());

+ const CChain& index_chain = chainstate.m_chain;

+

+ if (!index_chain.Contains(pindex)) {

+ pindex = index_chain.FindFork(pindex);

+ if (!chainman.m_blockman.CheckBlockDataAvailability(*index_chain.Tip(), *Assert(start_block))) {

+enum class ChainstateRole;

+ //! For each outpoint, calculate the fee-bumping cost to spend this outpoint at the specified

+ // feerate, including bumping its ancestors. For example, if the target feerate is 10sat/vbyte

+ // and this outpoint refers to a mempool transaction at 3sat/vbyte, the bump fee includes the

+ // cost to bump the mempool transaction to 10sat/vbyte (i.e. 7 * mempooltx.vsize). If that

+ // transaction also has, say, an unconfirmed parent with a feerate of 1sat/vbyte, the bump fee

+ // includes the cost to bump the parent (i.e. 9 * parentmempooltx.vsize).

+ //

+ // If the outpoint comes from an unconfirmed transaction that is already above the target

+ // feerate or bumped by its descendant(s) already, it does not need to be bumped. Its bump fee

+ // is 0. Likewise, if any of the transaction's ancestors are already bumped by a transaction

+ // in our mempool, they are not included in the transaction's bump fee.

+ //

+ // Also supported is bump-fee calculation in the case of replacements. If an outpoint

+ // conflicts with another transaction in the mempool, it is assumed that the goal is to replace

+ // that transaction. As such, the calculation will exclude the to-be-replaced transaction, but

+ // will include the fee-bumping cost. If bump fees of descendants of the to-be-replaced

+ // transaction are requested, the value will be 0. Fee-related RBF rules are not included as

+ // they are logically distinct.

+ //

+ // Any outpoints that are otherwise unavailable from the mempool (e.g. UTXOs from confirmed

+ // transactions or transactions not yet broadcast by the wallet) are given a bump fee of 0.

+ //

+ // If multiple outpoints come from the same transaction (which would be very rare because

+ // it means that one transaction has multiple change outputs or paid the same wallet using multiple

+ // outputs in the same transaction) or have shared ancestry, the bump fees are calculated

+ // independently, i.e. as if only one of them is spent. This may result in double-fee-bumping. This

+ // caveat can be rectified per use of the sister-function CalculateCombinedBumpFee(…).

+ virtual std::map<COutPoint, CAmount> CalculateIndividualBumpFees(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) = 0;

+

+ //! Calculate the combined bump fee for an input set per the same strategy

+ // as in CalculateIndividualBumpFees(…).

+ // Unlike CalculateIndividualBumpFees(…), this does not return individual

+ // bump fees per outpoint, but a single bump fee for the shared ancestry.

+ // The combined bump fee may be used to correct overestimation due to

+ // shared ancestry by multiple UTXOs after coin selection.

+ virtual std::optional<CAmount> CalculateCombinedBumpFee(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) = 0;

+

+ virtual void blockConnected(ChainstateRole role, const BlockInfo& block) {}

+ virtual void chainStateFlushed(ChainstateRole role, const CBlockLocator& locator) {}

+struct WalletMigrationResult;

+ //! Migrate a wallet

+ virtual util::Result<WalletMigrationResult> migrateWallet(const std::string& name, const SecureString& passphrase) = 0;

+

+ std::vector<bool> txout_is_change;

+//! Migrated wallet info

+struct WalletMigrationResult

+{

+ std::unique_ptr<Wallet> wallet;

+ std::optional<std::string> watchonly_wallet_name;

+ std::optional<std::string> solvables_wallet_name;

+ fs::path backup_path;

+};

+

+#include <kernel/chain.h>

+

+std::ostream& operator<<(std::ostream& os, const ChainstateRole& role) {

+ switch(role) {

+ case ChainstateRole::NORMAL: os << "normal"; break;

+ case ChainstateRole::ASSUMEDVALID: os << "assumedvalid"; break;

+ case ChainstateRole::BACKGROUND: os << "background"; break;

+ default: os.setstate(std::ios_base::failbit);

+ }

+ return os;

+}

+#include<iostream>

+

+

+//! This enum describes the various roles a specific Chainstate instance can take.

+//! Other parts of the system sometimes need to vary in behavior depending on the

+//! existence of a background validation chainstate, e.g. when building indexes.

+enum class ChainstateRole {

+ // Single chainstate in use, "normal" IBD mode.

+ NORMAL,

+

+ // Doing IBD-style validation in the background. Implies use of an assumed-valid

+ // chainstate.

+ BACKGROUND,

+

+ // Active assumed-valid chainstate. Implies use of a background IBD chainstate.

+ ASSUMEDVALID,

+};

+

+std::ostream& operator<<(std::ostream& os, const ChainstateRole& role);

+

+ m_assumeutxo_data = {

+ // TODO to be specified in a future patch.

+ m_assumeutxo_data = {

+ {

+ .height = 2'500'000,

+ .hash_serialized = AssumeutxoHash{uint256S("0x2a8fdefef3bf75fa00540ccaaaba4b5281bea94229327bdb0f7416ef1e7a645c")},

+ .nChainTx = 66484552,

+ .blockhash = uint256S("0x0000000000000093bcb68c03a9a168ae252572d348a2eaeba2cdf9231d73206f")

+ }

+ m_assumeutxo_data = {

+ {

+ .height = 160'000,

+ .hash_serialized = AssumeutxoHash{uint256S("0x5225141cb62dee63ab3be95f9b03d60801f264010b1816d4bd00618b2736e7be")},

+ .nChainTx = 2289496,

+ .blockhash = uint256S("0x0000003ca3c99aff040f2563c2ad8f8ec88bd0fd6b8f0895cfaf1ef90353a62c")

+ }

+ };

+

+ m_assumeutxo_data = {

+ .height = 110,

+ .hash_serialized = AssumeutxoHash{uint256S("0x1ebbf5850204c0bdb15bf030f47c7fe91d45c44c712697e4509ba67adb01c618")},

+ .nChainTx = 110,

+ .blockhash = uint256S("0x696e92821f65549c7ee134edceeeeaaa4105647a3c4fd9f298c0aec0ab50425c")

+ // For use by test/functional/feature_assumeutxo.py

+ .height = 299,

+ .hash_serialized = AssumeutxoHash{uint256S("0xef45ccdca5898b6c2145e4581d2b88c56564dd389e4bd75a1aaf6961d3edd3c0")},

+ .nChainTx = 300,

+ .blockhash = uint256S("0x7e0517ef3ea6ecbed9117858e42eedc8eb39e8698a38dcbd1b3962a283233f4c")

+#include <util/vector.h>

+ int height;

+

+ AssumeutxoHash hash_serialized;

+ unsigned int nChainTx;

+ //! The hash of the base block for this snapshot. Used to refer to assumeutxo data

+ //! prior to having a loaded blockindex.

+ uint256 blockhash;

+};

+ bool IsTestChain() const { return m_chain_type != ChainType::MAIN; }

+ std::optional<AssumeutxoData> AssumeutxoForHeight(int height) const

+ {

+ return FindFirst(m_assumeutxo_data, [&](const auto& d) { return d.height == height; });

+ }

+ std::optional<AssumeutxoData> AssumeutxoForBlockhash(const uint256& blockhash) const

+ {

+ return FindFirst(m_assumeutxo_data, [&](const auto& d) { return d.blockhash == blockhash; });

+ }

+ std::vector<AssumeutxoData> m_assumeutxo_data;

+// Copyright (c) 2023 The Bitcoin Core developers

+// Distributed under the MIT software license, see the accompanying

+// file COPYING or http://www.opensource.org/licenses/mit-license.php.

+

+#ifndef BITCOIN_KERNEL_DISCONNECTED_TRANSACTIONS_H

+#define BITCOIN_KERNEL_DISCONNECTED_TRANSACTIONS_H

+

+#include <core_memusage.h>

+#include <memusage.h>

+#include <primitives/transaction.h>

+#include <util/hasher.h>

+

+#include <list>

+#include <unordered_map>

+#include <vector>

+

+/** Maximum kilobytes for transactions to store for processing during reorg */

+static const unsigned int MAX_DISCONNECTED_TX_POOL_SIZE = 20'000;

+/**

+ * DisconnectedBlockTransactions

+

+ * During the reorg, it's desirable to re-add previously confirmed transactions

+ * to the mempool, so that anything not re-confirmed in the new chain is

+ * available to be mined. However, it's more efficient to wait until the reorg

+ * is complete and process all still-unconfirmed transactions at that time,

+ * since we expect most confirmed transactions to (typically) still be

+ * confirmed in the new chain, and re-accepting to the memory pool is expensive

+ * (and therefore better to not do in the middle of reorg-processing).

+ * Instead, store the disconnected transactions (in order!) as we go, remove any

+ * that are included in blocks in the new chain, and then process the remaining

+ * still-unconfirmed transactions at the end.

+ *

+ * Order of queuedTx:

+ * The front of the list should be the most recently-confirmed transactions (transactions at the

+ * end of vtx of blocks closer to the tip). If memory usage grows too large, we trim from the front

+ * of the list. After trimming, transactions can be re-added to the mempool from the back of the

+ * list to the front without running into missing inputs.

+ */

+class DisconnectedBlockTransactions {

+private:

+ /** Cached dynamic memory usage for the CTransactions (memory for the shared pointers is

+ * included in the container calculations). */

+ uint64_t cachedInnerUsage = 0;

+ const size_t m_max_mem_usage;

+ std::list<CTransactionRef> queuedTx;

+ using TxList = decltype(queuedTx);

+ std::unordered_map<uint256, TxList::iterator, SaltedTxidHasher> iters_by_txid;

+

+ /** Trim the earliest-added entries until we are within memory bounds. */

+ std::vector<CTransactionRef> LimitMemoryUsage()

+ {

+ std::vector<CTransactionRef> evicted;

+

+ while (!queuedTx.empty() && DynamicMemoryUsage() > m_max_mem_usage) {

+ evicted.emplace_back(queuedTx.front());

+ cachedInnerUsage -= RecursiveDynamicUsage(*queuedTx.front());

+ iters_by_txid.erase(queuedTx.front()->GetHash());

+ queuedTx.pop_front();

+ }

+ return evicted;

+ }

+

+public:

+ DisconnectedBlockTransactions(size_t max_mem_usage) : m_max_mem_usage{max_mem_usage} {}

+

+ // It's almost certainly a logic bug if we don't clear out queuedTx before

+ // destruction, as we add to it while disconnecting blocks, and then we

+ // need to re-process remaining transactions to ensure mempool consistency.

+ // For now, assert() that we've emptied out this object on destruction.

+ // This assert() can always be removed if the reorg-processing code were

+ // to be refactored such that this assumption is no longer true (for

+ // instance if there was some other way we cleaned up the mempool after a

+ // reorg, besides draining this object).

+ ~DisconnectedBlockTransactions() {

+ assert(queuedTx.empty());

+ assert(iters_by_txid.empty());

+ assert(cachedInnerUsage == 0);

+ }

+

+ size_t DynamicMemoryUsage() const {

+ return cachedInnerUsage + memusage::DynamicUsage(iters_by_txid) + memusage::DynamicUsage(queuedTx);

+ }

+

+ /** Add transactions from the block, iterating through vtx in reverse order. Callers should call

+ * this function for blocks in descending order by block height.

+ * We assume that callers never pass multiple transactions with the same txid, otherwise things

+ * can go very wrong in removeForBlock due to queuedTx containing an item without a

+ * corresponding entry in iters_by_txid.

+ * @returns vector of transactions that were evicted for size-limiting.

+ */

+ [[nodiscard]] std::vector<CTransactionRef> AddTransactionsFromBlock(const std::vector<CTransactionRef>& vtx)

+ {

+ iters_by_txid.reserve(iters_by_txid.size() + vtx.size());

+ for (auto block_it = vtx.rbegin(); block_it != vtx.rend(); ++block_it) {

+ auto it = queuedTx.insert(queuedTx.end(), *block_it);

+ iters_by_txid.emplace((*block_it)->GetHash(), it);

+ cachedInnerUsage += RecursiveDynamicUsage(**block_it);

+ }

+ return LimitMemoryUsage();

+ }

+

+ /** Remove any entries that are in this block. */

+ void removeForBlock(const std::vector<CTransactionRef>& vtx)

+ {

+ // Short-circuit in the common case of a block being added to the tip

+ if (queuedTx.empty()) {

+ return;

+ }

+ for (const auto& tx : vtx) {

+ auto iter = iters_by_txid.find(tx->GetHash());

+ if (iter != iters_by_txid.end()) {

+ auto list_iter = iter->second;

+ iters_by_txid.erase(iter);

+ cachedInnerUsage -= RecursiveDynamicUsage(**list_iter);

+ queuedTx.erase(list_iter);

+ }

+ }

+ }

+

+ size_t size() const { return queuedTx.size(); }

+

+ void clear()

+ {

+ cachedInnerUsage = 0;

+ iters_by_txid.clear();

+ queuedTx.clear();

+ }

+

+ /** Clear all data structures and return the list of transactions. */

+ std::list<CTransactionRef> take()

+ {

+ std::list<CTransactionRef> ret = std::move(queuedTx);

+ clear();

+ return ret;

+ }

+};

+#endif // BITCOIN_KERNEL_DISCONNECTED_TRANSACTIONS_H

+ MakeKeyData();

+ GetStrongRandBytes(*keydata);

+ } while (!Check(keydata->data()));

+ assert(keydata);

+ return secp256k1_ec_seckey_negate(secp256k1_context_sign, keydata->data());

+ assert(keydata);

+ assert(keydata);

+ if (!keydata)

+ if (!keydata)

+ MakeKeyData();

+ if (!ec_seckey_import_der(secp256k1_context_sign, (unsigned char*)begin(), seckey.data(), seckey.size())) {

+ ClearKeyData();

+ }

+ keyChild.Set(begin(), begin() + 32, true);

+ if (!ret) keyChild.ClearKeyData();

+ assert(keydata);

+ keydata->data(),

+ assert(keydata);

+ keydata->data(),

+ /** Internal data container for private key material. */

+ using KeyType = std::array<unsigned char, 32>;

+ //! The actual byte data. nullptr for invalid keys.

+ secure_unique_ptr<KeyType> keydata;

+ void MakeKeyData()

+ {

+ if (!keydata) keydata = make_secure_unique<KeyType>();

+ }

+

+ void ClearKeyData()

+ {

+ keydata.reset();

+ }

+

+ CKey() noexcept = default;

+ CKey(CKey&&) noexcept = default;

+ CKey& operator=(CKey&&) noexcept = default;

+

+ CKey& operator=(const CKey& other)

+ if (other.keydata) {

+ MakeKeyData();

+ *keydata = *other.keydata;

+ } else {

+ ClearKeyData();

+ }

+ fCompressed = other.fCompressed;

+ return *this;

+ CKey(const CKey& other) { *this = other; }

+

+ memcmp(a.data(), b.data(), a.size()) == 0;

+ if (size_t(pend - pbegin) != std::tuple_size_v<KeyType>) {

+ ClearKeyData();

+ MakeKeyData();

+ memcpy(keydata->data(), (unsigned char*)&pbegin[0], keydata->size());

+ ClearKeyData();

+ unsigned int size() const { return keydata ? keydata->size() : 0; }

+ const std::byte* data() const { return keydata ? reinterpret_cast<const std::byte*>(keydata->data()) : nullptr; }

+ const unsigned char* begin() const { return keydata ? keydata->data() : nullptr; }

+ const unsigned char* end() const { return begin() + size(); }

+ bool IsValid() const { return !!keydata; }

+ const std::vector<unsigned char>& program = id.GetWitnessProgram();

+ if (id.GetWitnessVersion() < 1 || id.GetWitnessVersion() > 16 || program.size() < 2 || program.size() > 40) {

+ std::vector<unsigned char> data = {(unsigned char)id.GetWitnessVersion()};

+ data.reserve(1 + (program.size() * 8 + 4) / 5);

+ ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, program.begin(), program.end());

+ std::string operator()(const PubKeyDestination& pk) const { return {}; }

+ return WitnessUnknown{version, data};

+#include <list>

+struct list_node

+{

+private:

+ void* ptr_next;

+ void* ptr_prev;

+ X x;

+};

+

+template<typename X>

+static inline size_t DynamicUsage(const std::list<X>& l)

+{

+ return MallocUsage(sizeof(list_node<X>)) * l.size();

+}

+

+template<typename X>

+#include <util/vector.h>

+// Determine the "best" local address for a particular peer.

+[[nodiscard]] static std::optional<CService> GetLocal(const CNode& peer)

+ if (!fListen) return std::nullopt;

+ std::optional<CService> addr;

+ for (const auto& [local_addr, local_service_info] : mapLocalHost) {

+ if (local_addr.GetNetwork() != peer.ConnectedThroughNetwork()

+ && (local_addr.IsPrivacyNet() || peer.IsConnectedThroughPrivacyNet())) {

+ const int nScore{local_service_info.nScore};

+ const int nReachability{local_addr.GetReachabilityFrom(peer.addr)};

+ if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore)) {

+ addr.emplace(CService{local_addr, local_service_info.nPort});

+ return addr;

+// Determine the "best" local address for a particular peer.

+// If none, return the unroutable 0.0.0.0 but filled in with

+ return GetLocal(peer).value_or(CService{CNetAddr(), GetListenPort()});

+[[nodiscard]] static bool IsPeerAddrLocalGood(CNode *pnode)

+ if (ret.IsIPv6() && ret.HasCJDNSPrefix() && IsReachable(NET_CJDNS)) {

+CNode* CConnman::ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure, ConnectionType conn_type, bool use_v2transport)

+ LogPrintLevel(BCLog::NET, BCLog::Level::Debug, "trying %s connection %s lastseen=%.1fhrs\n",

+ use_v2transport ? "v2" : "v1",

+ if (addrConnect.IsI2P() && use_proxy) {

+ .use_v2transport = use_v2transport,

+bool CNode::IsConnectedThroughPrivacyNet() const

+{

+ return m_inbound_onion || addr.IsPrivacyNet();

+}

+

+ Transport::Info info = m_transport->GetInfo();

+ stats.m_transport_type = info.transport_type;

+ if (info.session_id) stats.m_session_id = HexStr(*info.session_id);

+Transport::Info V1Transport::GetInfo() const noexcept

+{

+ return {.transport_type = TransportProtocolType::V1, .session_id = {}};

+}

+

+ CVectorWriter{INIT_PROTO_VERSION, m_header_to_send, 0, hdr};

+ ClearShrink(m_message_to_send.data);

+ // We cannot wipe m_send_garbage as it will still be used as AAD later in the handshake.

+ ClearShrink(m_recv_buffer);

+ ClearShrink(m_send_buffer);

+ // Construct version packet in the send buffer, with the sent garbage data as AAD.

+ /*aad=*/MakeByteSpan(m_send_garbage),

+ // We no longer need the garbage.

+ ClearShrink(m_send_garbage);

+ // Garbage terminator received. Store garbage to authenticate it as AAD later.

+ m_recv_aad = std::move(m_recv_buffer);

+ m_recv_aad.resize(m_recv_aad.size() - BIP324Cipher::GARBAGE_TERMINATOR_LEN);

+ SetReceiveState(RecvState::VERSION);

+ Assume(m_recv_state == RecvState::VERSION || m_recv_state == RecvState::APP);

+ /*aad=*/MakeByteSpan(m_recv_aad),

+ // We have decrypted a valid packet with the AAD we expected, so clear the expected AAD.

+ ClearShrink(m_recv_aad);

+ // At this point we have a valid packet decrypted into m_recv_decode_buffer. If it's not a

+ // decoy, which we simply ignore, use the current state to decide what to do with it.

+ if (!ignore) {

+ switch (m_recv_state) {

+ case RecvState::VERSION:

+ break;

+ case RecvState::APP:

+ break;

+ default:

+ // Any other state is invalid (this function should not have been called).

+ Assume(false);

+ ClearShrink(m_recv_buffer);

+ if (m_recv_state != RecvState::APP_READY) ClearShrink(m_recv_decode_buffer);

+ ClearShrink(m_recv_decode_buffer);

+ ClearShrink(msg.data);

+ if (m_send_state == SendState::AWAITING_KEY && m_send_pos == 0 && bytes_sent > 0) {

+ LogPrint(BCLog::NET, "start sending v2 handshake to peer=%d\n", m_nodeid);

+ }

+

+ if (m_send_pos >= CMessageHeader::HEADER_SIZE) {

+ m_sent_v1_header_worth = true;

+ }

+ ClearShrink(m_send_buffer);

+bool V2Transport::ShouldReconnectV1() const noexcept

+{

+ AssertLockNotHeld(m_send_mutex);

+ AssertLockNotHeld(m_recv_mutex);

+ // Only outgoing connections need reconnection.

+ if (!m_initiating) return false;

+

+ LOCK(m_recv_mutex);

+ // We only reconnect in the very first state and when the receive buffer is empty. Together

+ // these conditions imply nothing has been received so far.

+ if (m_recv_state != RecvState::KEY) return false;

+ if (!m_recv_buffer.empty()) return false;

+ // Check if we've sent enough for the other side to disconnect us (if it was V1).

+ LOCK(m_send_mutex);

+ return m_sent_v1_header_worth;

+}

+

+Transport::Info V2Transport::GetInfo() const noexcept

+{

+ AssertLockNotHeld(m_recv_mutex);

+ LOCK(m_recv_mutex);

+ if (m_recv_state == RecvState::V1) return m_v1_fallback.GetInfo();

+

+ Transport::Info info;

+

+ // Do not report v2 and session ID until the version packet has been received

+ // and verified (confirming that the other side very likely has the same keys as us).

+ if (m_recv_state != RecvState::KEY_MAYBE_V1 && m_recv_state != RecvState::KEY &&

+ m_recv_state != RecvState::GARB_GARBTERM && m_recv_state != RecvState::VERSION) {

+ info.transport_type = TransportProtocolType::V2;

+ info.session_id = uint256(MakeUCharSpan(m_cipher.GetSessionID()));

+ } else {

+ info.transport_type = TransportProtocolType::DETECTING;

+ }

+

+ return info;

+}

+

+ if (!msg_type.empty()) { // don't report v2 handshake bytes for now

+ node.AccountForSentBytes(msg_type, nBytes);

+ }

+ // The V2Transport transparently falls back to V1 behavior when an incoming V1 connection is

+ // detected, so use it whenever we signal NODE_P2P_V2.

+ const bool use_v2transport(nodeServices & NODE_P2P_V2);

+

+ .use_v2transport = use_v2transport,

+ OpenNetworkConnection(CAddress(), false, std::move(grant), address.c_str(), conn_type, /*use_v2transport=*/false);

+ AssertLockNotHeld(m_nodes_mutex);

+ AssertLockNotHeld(m_reconnections_mutex);

+

+ // Use a temporary variable to accumulate desired reconnections, so we don't need

+ // m_reconnections_mutex while holding m_nodes_mutex.

+ decltype(m_reconnections) reconnections_to_add;

+

+ // Add to reconnection list if appropriate. We don't reconnect right here, because

+ // the creation of a connection is a blocking operation (up to several seconds),

+ // and we don't want to hold up the socket handler thread for that long.

+ if (pnode->m_transport->ShouldReconnectV1()) {

+ reconnections_to_add.push_back({

+ .addr_connect = pnode->addr,

+ .grant = std::move(pnode->grantOutbound),

+ .destination = pnode->m_dest,

+ .conn_type = pnode->m_conn_type,

+ .use_v2transport = false});

+ LogPrint(BCLog::NET, "retrying with v1 transport protocol for peer=%d\n", pnode->GetId());

+ }

+

+ {

+ // Move entries from reconnections_to_add to m_reconnections.

+ LOCK(m_reconnections_mutex);

+ m_reconnections.splice(m_reconnections.end(), std::move(reconnections_to_add));

+ }

+ CSemaphoreGrant grant(*semOutbound, /*fTry=*/true);

+ OpenNetworkConnection(addr, false, std::move(grant), strDest.c_str(), ConnectionType::ADDR_FETCH, /*use_v2transport=*/false);

+ AssertLockNotHeld(m_reconnections_mutex);

+ OpenNetworkConnection(addr, false, {}, strAddr.c_str(), ConnectionType::MANUAL, /*use_v2transport=*/false);

+ PerformReconnections();

+

+ if (m_added_node_params.empty()) {

+ // Use BIP324 transport when both us and them have NODE_V2_P2P set.

+ const bool use_v2transport(addrConnect.nServices & GetLocalServices() & NODE_P2P_V2);

+ OpenNetworkConnection(addrConnect, count_failures, std::move(grant), /*strDest=*/nullptr, conn_type, use_v2transport);

+ std::list<AddedNodeParams> lAddresses(0);

+ ret.reserve(m_added_node_params.size());

+ std::copy(m_added_node_params.cbegin(), m_added_node_params.cend(), std::back_inserter(lAddresses));

+ for (const auto& addr : lAddresses) {

+ CService service(LookupNumeric(addr.m_added_node, GetDefaultPort(addr.m_added_node)));

+ AddedNodeInfo addedNode{addr, CService(), false, false};

+ auto it = mapConnectedByName.find(addr.m_added_node);

+ AssertLockNotHeld(m_reconnections_mutex);

+ if (!grant) {

+ OpenNetworkConnection(addr, false, std::move(grant), info.m_params.m_added_node.c_str(), ConnectionType::MANUAL, info.m_params.m_use_v2transport);

+ if (!interruptNet.sleep_for(std::chrono::milliseconds(500))) return;

+ grant = CSemaphoreGrant(*semAddnode, /*fTry=*/true);

+ // See if any reconnections are desired.

+ PerformReconnections();

+void CConnman::OpenNetworkConnection(const CAddress& addrConnect, bool fCountFailure, CSemaphoreGrant&& grant_outbound, const char *pszDest, ConnectionType conn_type, bool use_v2transport)

+ CNode* pnode = ConnectNode(addrConnect, pszDest, fCountFailure, conn_type, use_v2transport);

+ pnode->grantOutbound = std::move(grant_outbound);

+bool CConnman::AddNode(const AddedNodeParams& add)

+ for (const auto& it : m_added_node_params) {

+ if (add.m_added_node == it.m_added_node) return false;

+ m_added_node_params.push_back(add);

+ for (auto it = m_added_node_params.begin(); it != m_added_node_params.end(); ++it) {

+ if (strNode == it->m_added_node) {

+ m_added_node_params.erase(it);

+static std::unique_ptr<Transport> MakeTransport(NodeId id, bool use_v2transport, bool inbound) noexcept

+{

+ if (use_v2transport) {

+ return std::make_unique<V2Transport>(id, /*initiating=*/!inbound, SER_NETWORK, INIT_PROTO_VERSION);

+ } else {

+ return std::make_unique<V1Transport>(id, SER_NETWORK, INIT_PROTO_VERSION);

+ }

+}

+

+ : m_transport{MakeTransport(idIn, node_opts.use_v2transport, conn_type_in == ConnectionType::INBOUND)},

+ m_dest(addrNameIn),

+void CConnman::PerformReconnections()

+{

+ AssertLockNotHeld(m_reconnections_mutex);

+ AssertLockNotHeld(m_unused_i2p_sessions_mutex);

+ while (true) {

+ // Move first element of m_reconnections to todo (avoiding an allocation inside the lock).

+ decltype(m_reconnections) todo;

+ {

+ LOCK(m_reconnections_mutex);

+ if (m_reconnections.empty()) break;

+ todo.splice(todo.end(), m_reconnections, m_reconnections.begin());

+ }

+

+ auto& item = *todo.begin();

+ OpenNetworkConnection(item.addr_connect,

+ // We only reconnect if the first attempt to connect succeeded at

+ // connection time, but then failed after the CNode object was

+ // created. Since we already know connecting is possible, do not

+ // count failure to reconnect.

+ /*fCountFailure=*/false,

+ std::move(item.grant),

+ item.destination.empty() ? nullptr : item.destination.c_str(),

+ item.conn_type,

+ item.use_v2transport);

+ }

+}

+

+// Dump binary message to file, with timestamp.

+static void CaptureMessageToFile(const CAddress& addr,

+ const std::string& msg_type,

+ Span<const unsigned char> data,

+ bool is_incoming)

+static constexpr bool DEFAULT_V2_TRANSPORT{false};

+

+struct AddedNodeParams {

+ std::string m_added_node;

+ bool m_use_v2transport;

+};

+

+struct AddedNodeInfo {

+ AddedNodeParams m_params;

+ /** Transport protocol type. */

+ TransportProtocolType m_transport_type;

+ /** BIP324 session id string in hex, if any. */

+ std::string m_session_id;

+ struct Info

+ {

+ TransportProtocolType transport_type;

+ std::optional<uint256> session_id;

+ };

+

+ /** Retrieve information about this transport. */

+ virtual Info GetInfo() const noexcept = 0;

+

+

+ // 3. Miscellaneous functions.

+

+ /** Whether upon disconnections, a reconnect with V1 is warranted. */

+ virtual bool ShouldReconnectV1() const noexcept = 0;

+ Info GetInfo() const noexcept override;

+

+ bool ShouldReconnectV1() const noexcept override { return false; }

+ * | start(initiator) /---------\

+ * | | | |

+ * v v v |

+ * KEY_MAYBE_V1 -> KEY -> GARB_GARBTERM -> VERSION -> APP -> APP_READY

+ * terminator. When that happens, the state becomes VERSION. If no matching terminator is

+ * A packet is received, and decrypted/verified. If that fails, the connection aborts. The

+ * first received packet in this state (whether it's a decoy or not) is expected to

+ * authenticate the garbage received during the GARB_GARBTERM state as associated

+ * authenticated data (AAD). The first non-decoy packet in this state is interpreted as

+ * version negotiation (currently, that means ignoring the contents, but it can be used for

+ * negotiating future extensions), and afterwards the state becomes APP. */

+ * entered, the garbage terminator and version packet are appended to the send buffer (in

+ * addition to the key and garbage which may still be there). In this state a message can be

+ * provided if the send buffer is empty. */

+ /** In {VERSION, APP}, the decrypted packet length, if m_recv_buffer.size() >=

+ /** AAD expected in next received packet (currently used only for garbage). */

+ std::vector<uint8_t> m_recv_aad GUARDED_BY(m_recv_mutex);

+ /** Whether we've sent at least 24 bytes (which would trigger disconnect for V1 peers). */

+ bool m_sent_v1_header_worth GUARDED_BY(m_send_mutex) {false};

+ /** Process bytes in m_recv_buffer, while in VERSION/APP state. */

+

+ // Miscellaneous functions.

+ bool ShouldReconnectV1() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex, !m_send_mutex);

+ Info GetInfo() const noexcept override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex);

+ bool use_v2transport = false;

+ /** The pszDest argument provided to ConnectNode(). Only used for reconnections. */

+ const std::string m_dest;

+ /** Whether this peer connected through a privacy network. */

+ [[nodiscard]] bool IsConnectedThroughPrivacyNet() const;

+

+

+ for (const std::string& added_node : connOptions.m_added_nodes) {

+ // -addnode cli arg does not currently have a way to signal BIP324 support

+ m_added_node_params.push_back({added_node, false});

+ }

+ void OpenNetworkConnection(const CAddress& addrConnect, bool fCountFailure, CSemaphoreGrant&& grant_outbound, const char* strDest, ConnectionType conn_type, bool use_v2transport) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex);

+ bool AddNode(const AddedNodeParams& add) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex);

+ void ThreadOpenAddedConnections() EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex, !m_unused_i2p_sessions_mutex, !m_reconnections_mutex);

+ void ThreadOpenConnections(std::vector<std::string> connect) EXCLUSIVE_LOCKS_REQUIRED(!m_addr_fetches_mutex, !m_added_nodes_mutex, !m_nodes_mutex, !m_unused_i2p_sessions_mutex, !m_reconnections_mutex);

+ void DisconnectNodes() EXCLUSIVE_LOCKS_REQUIRED(!m_reconnections_mutex, !m_nodes_mutex);

+ void ThreadSocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_total_bytes_sent_mutex, !mutexMsgProc, !m_nodes_mutex, !m_reconnections_mutex);

+ CNode* ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure, ConnectionType conn_type, bool use_v2transport) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex);

+

+ // connection string and whether to use v2 p2p

+ std::vector<AddedNodeParams> m_added_node_params GUARDED_BY(m_added_nodes_mutex);

+

+ * Mutex protecting m_reconnections.

+ */

+ Mutex m_reconnections_mutex;

+

+ /** Struct for entries in m_reconnections. */

+ struct ReconnectionInfo

+ {

+ CAddress addr_connect;

+ CSemaphoreGrant grant;

+ std::string destination;

+ ConnectionType conn_type;

+ bool use_v2transport;

+ };

+

+ /**

+ * List of reconnections we have to make.

+ */

+ std::list<ReconnectionInfo> m_reconnections GUARDED_BY(m_reconnections_mutex);

+

+ /** Attempt reconnections, if m_reconnections non-empty. */

+ void PerformReconnections() EXCLUSIVE_LOCKS_REQUIRED(!m_reconnections_mutex, !m_unused_i2p_sessions_mutex);

+

+ /**

+#include <kernel/chain.h>

+ void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindexConnected) override

+ /** Request blocks for the background chainstate, if one is in use. */

+ void TryDownloadingHistoricalBlocks(const Peer& peer, unsigned int count, std::vector<const CBlockIndex*>& vBlocks, const CBlockIndex* from_tip, const CBlockIndex* target_block) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+

+ /**

+ * \brief Find next blocks to download from a peer after a starting block.

+ *

+ * \param vBlocks Vector of blocks to download which will be appended to.

+ * \param peer Peer which blocks will be downloaded from.

+ * \param state Pointer to the state of the peer.

+ * \param pindexWalk Pointer to the starting block to add to vBlocks.

+ * \param count Maximum number of blocks to allow in vBlocks. No more

+ * blocks will be added if it reaches this size.

+ * \param nWindowEnd Maximum height of blocks to allow in vBlocks. No

+ * blocks will be added above this height.

+ * \param activeChain Optional pointer to a chain to compare against. If

+ * provided, any next blocks which are already contained

+ * in this chain will not be appended to vBlocks, but

+ * instead will be used to update the

+ * state->pindexLastCommonBlock pointer.

+ * \param nodeStaller Optional pointer to a NodeId variable that will receive

+ * the ID of another peer that might be causing this peer

+ * to stall. This is set to the ID of the peer which

+ * first requested the first in-flight block in the

+ * download window. It is only set if vBlocks is empty at

+ * the end of this function call and if increasing

+ * nWindowEnd by 1 would cause it to be non-empty (which

+ * indicates the download might be stalled because every

+ * block in the window is in flight and no other peer is

+ * trying to download the next block).

+ */

+ void FindNextBlocks(std::vector<const CBlockIndex*>& vBlocks, const Peer& peer, CNodeState *state, const CBlockIndex *pindexWalk, unsigned int count, int nWindowEnd, const CChain* activeChain=nullptr, NodeId* nodeStaller=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+

+// Logic for calculating which blocks to download from a given peer, given our current tip.

+

+ FindNextBlocks(vBlocks, peer, state, pindexWalk, count, nWindowEnd, &m_chainman.ActiveChain(), &nodeStaller);

+}

+

+void PeerManagerImpl::TryDownloadingHistoricalBlocks(const Peer& peer, unsigned int count, std::vector<const CBlockIndex*>& vBlocks, const CBlockIndex *from_tip, const CBlockIndex* target_block)

+{

+ Assert(from_tip);

+ Assert(target_block);

+

+ if (vBlocks.size() >= count) {

+ return;

+ }

+

+ vBlocks.reserve(count);

+ CNodeState *state = Assert(State(peer.m_id));

+

+ if (state->pindexBestKnownBlock == nullptr || state->pindexBestKnownBlock->GetAncestor(target_block->nHeight) != target_block) {

+ // This peer can't provide us the complete series of blocks leading up to the

+ // assumeutxo snapshot base.

+ //

+ // Presumably this peer's chain has less work than our ActiveChain()'s tip, or else we

+ // will eventually crash when we try to reorg to it. Let other logic

+ // deal with whether we disconnect this peer.

+ //

+ // TODO at some point in the future, we might choose to request what blocks

+ // this peer does have from the historical chain, despite it not having a

+ // complete history beneath the snapshot base.

+ return;

+ }

+

+ FindNextBlocks(vBlocks, peer, state, from_tip, count, std::min<int>(from_tip->nHeight + BLOCK_DOWNLOAD_WINDOW, target_block->nHeight));

+}

+

+void PeerManagerImpl::FindNextBlocks(std::vector<const CBlockIndex*>& vBlocks, const Peer& peer, CNodeState *state, const CBlockIndex *pindexWalk, unsigned int count, int nWindowEnd, const CChain* activeChain, NodeId* nodeStaller)

+{

+ std::vector<const CBlockIndex*> vToFetch;

+ if (pindex->nStatus & BLOCK_HAVE_DATA || (activeChain && activeChain->Contains(pindex))) {

+ if (activeChain && pindex->HaveTxsDownloaded())

+ if (nodeStaller) *nodeStaller = waitingfor;

+ your_services, CNetAddr::V1(addr_you), // Together the pre-version-31402 serialization of CAddress "addrYou" (without nTime)

+ my_services, CNetAddr::V1(CService{}), // Together the pre-version-31402 serialization of CAddress "addrMe" (without nTime)

+void PeerManagerImpl::BlockConnected(

+ ChainstateRole role,

+ const std::shared_ptr<const CBlock>& pblock,

+ const CBlockIndex* pindex)

+ // Update this for all chainstate roles so that we don't mistakenly see peers

+ // helping us do background IBD as having a stale tip.

+ // In case the dynamic timeout was doubled once or more, reduce it slowly back to its default value

+ auto stalling_timeout = m_block_stalling_timeout.load();

+ Assume(stalling_timeout >= BLOCK_STALLING_TIMEOUT_DEFAULT);

+ if (stalling_timeout != BLOCK_STALLING_TIMEOUT_DEFAULT) {

+ const auto new_timeout = std::max(std::chrono::duration_cast<std::chrono::seconds>(stalling_timeout * 0.85), BLOCK_STALLING_TIMEOUT_DEFAULT);

+ if (m_block_stalling_timeout.compare_exchange_strong(stalling_timeout, new_timeout)) {

+ LogPrint(BCLog::NET, "Decreased stalling timeout to %d seconds\n", count_seconds(new_timeout));

+ }

+ }

+

+ if (role == ChainstateRole::BACKGROUND) {

+ return;

+ }

+ m_orphanage.EraseForBlock(*pblock);

+

+ vRecv >> CNetAddr::V1(addrMe);

+ // Log succesful connections unconditionally for outbound, but not for inbound as those

+ // can be triggered by an attacker at high rate.

+ if (!pfrom.IsInboundConn() || LogAcceptCategory(BCLog::NET, BCLog::Level::Debug)) {

+ LogPrintf("New %s %s peer connected: version: %d, blocks=%d, peer=%d%s%s\n",

+ pfrom.ConnectionTypeAsString(),

+ TransportTypeAsString(pfrom.m_transport->GetInfo().transport_type),

+ (mapped_as ? strprintf(", mapped_as=%d", mapped_as) : ""));

+ auto get_inflight_budget = [&state]() {

+ return std::max(0, MAX_BLOCKS_IN_TRANSIT_PER_PEER - static_cast<int>(state.vBlocksInFlight.size()));

+ };

+

+ // If a snapshot chainstate is in use, we want to find its next blocks

+ // before the background chainstate to prioritize getting to network tip.

+ FindNextBlocksToDownload(*peer, get_inflight_budget(), vToDownload, staller);

+ if (m_chainman.BackgroundSyncInProgress() && !IsLimitedPeer(*peer)) {

+ TryDownloadingHistoricalBlocks(

+ *peer,

+ get_inflight_budget(),

+ vToDownload, m_chainman.GetBackgroundSyncTip(),

+ Assert(m_chainman.GetSnapshotBaseBlock()));

+ }

+ if (IsCJDNS() && !HasCJDNSPrefix()) {

+ [[nodiscard]] bool IsIPv4() const { return m_net == NET_IPV4; } // IPv4 mapped address (::FFFF:0:0/96, 0.0.0.0/0)

+ [[nodiscard]] bool IsIPv6() const { return m_net == NET_IPV6; } // IPv6 address (not mapped IPv4, not Tor)

+ [[nodiscard]] bool IsTor() const { return m_net == NET_ONION; }

+ [[nodiscard]] bool IsI2P() const { return m_net == NET_I2P; }

+ [[nodiscard]] bool IsCJDNS() const { return m_net == NET_CJDNS; }

+ [[nodiscard]] bool HasCJDNSPrefix() const { return m_addr[0] == 0xfc; }

+ * Whether this object is a privacy network.

+ * TODO: consider adding IsCJDNS() here when more peers adopt CJDNS, see:

+ * https://github.com/bitcoin/bitcoin/pull/27411#issuecomment-1497176155

+ */

+ [[nodiscard]] bool IsPrivacyNet() const { return IsTor() || IsI2P(); }

+

+ /**

+ SER_PARAMS_OPFUNC

+ CVectorWriter{nFlags | nVersion, msg.data, 0, std::forward<Args>(args)...};

+#include <kernel/chain.h>

+void BlockManager::FindFilesToPruneManual(

+ std::set<int>& setFilesToPrune,

+ int nManualPruneHeight,

+ const Chainstate& chain,

+ ChainstateManager& chainman)

+ if (chain.m_chain.Height() < 0) {

+ const auto [min_block_to_prune, last_block_can_prune] = chainman.GetPruneRange(chain, nManualPruneHeight);

+

+ for (int fileNumber = 0; fileNumber < this->MaxBlockfileNum(); fileNumber++) {

+ const auto& fileinfo = m_blockfile_info[fileNumber];

+ if (fileinfo.nSize == 0 || fileinfo.nHeightLast > (unsigned)last_block_can_prune || fileinfo.nHeightFirst < (unsigned)min_block_to_prune) {

+

+ LogPrintf("[%s] Prune (Manual): prune_height=%d removed %d blk/rev pairs\n",

+ chain.GetRole(), last_block_can_prune, count);

+void BlockManager::FindFilesToPrune(

+ std::set<int>& setFilesToPrune,

+ int last_prune,

+ const Chainstate& chain,

+ ChainstateManager& chainman)

+ // Distribute our -prune budget over all chainstates.

+ const auto target = std::max(

+ MIN_DISK_SPACE_FOR_BLOCK_FILES, GetPruneTarget() / chainman.GetAll().size());

+

+ if (chain.m_chain.Height() < 0 || target == 0) {

+ if (static_cast<uint64_t>(chain.m_chain.Height()) <= chainman.GetParams().PruneAfterHeight()) {

+ const auto [min_block_to_prune, last_block_can_prune] = chainman.GetPruneRange(chain, last_prune);

+

+ if (nCurrentUsage + nBuffer >= target) {

+ if (chainman.IsInitialBlockDownload()) {

+ nBuffer += target / 10;

+ for (int fileNumber = 0; fileNumber < this->MaxBlockfileNum(); fileNumber++) {

+ const auto& fileinfo = m_blockfile_info[fileNumber];

+ nBytesToPrune = fileinfo.nSize + fileinfo.nUndoSize;

+ if (fileinfo.nSize == 0) {

+ if (nCurrentUsage + nBuffer < target) { // are we below our target?

+ // don't prune files that could have a block that's not within the allowable

+ // prune range for the chain being pruned.

+ if (fileinfo.nHeightLast > (unsigned)last_block_can_prune || fileinfo.nHeightFirst < (unsigned)min_block_to_prune) {

+ LogPrint(BCLog::PRUNE, "[%s] target=%dMiB actual=%dMiB diff=%dMiB min_height=%d max_prune_height=%d removed %d blk/rev pairs\n",

+ chain.GetRole(), target / 1024 / 1024, nCurrentUsage / 1024 / 1024,

+ (int64_t(target) - int64_t(nCurrentUsage)) / 1024 / 1024,

+ min_block_to_prune, last_block_can_prune, count);

+bool BlockManager::LoadBlockIndex(const std::optional<uint256>& snapshot_blockhash)

+ if (snapshot_blockhash) {

+ const AssumeutxoData au_data = *Assert(GetParams().AssumeutxoForBlockhash(*snapshot_blockhash));

+ m_snapshot_height = au_data.height;

+ CBlockIndex* base{LookupBlockIndex(*snapshot_blockhash)};

+

+ // Since nChainTx (responsible for estimated progress) isn't persisted

+ // to disk, we must bootstrap the value for assumedvalid chainstates

+ // from the hardcoded assumeutxo chainparams.

+ base->nChainTx = au_data.nChainTx;

+ LogPrintf("[snapshot] set nChainTx=%d for %s\n", au_data.nChainTx, snapshot_blockhash->ToString());

+ } else {

+ // If this isn't called with a snapshot blockhash, make sure the cached snapshot height

+ // is null. This is relevant during snapshot completion, when the blockman may be loaded

+ // with a height that then needs to be cleared after the snapshot is fully validated.

+ m_snapshot_height.reset();

+ }

+

+ Assert(m_snapshot_height.has_value() == snapshot_blockhash.has_value());

+

+ if (m_snapshot_height && pindex->nHeight == *m_snapshot_height &&

+ pindex->GetBlockHash() == *snapshot_blockhash) {

+ // Should have been set above; don't disturb it with code below.

+ Assert(pindex->nChainTx > 0);

+ } else if (pindex->pprev->nChainTx > 0) {

+ int max_blockfile = WITH_LOCK(cs_LastBlockFile, return this->MaxBlockfileNum());

+ if (!m_block_tree_db->WriteBatchSync(vFiles, max_blockfile, vBlocks)) {

+bool BlockManager::LoadBlockIndexDB(const std::optional<uint256>& snapshot_blockhash)

+ if (!LoadBlockIndex(snapshot_blockhash)) {

+ int max_blockfile_num{0};

+ m_block_tree_db->ReadLastBlockFile(max_blockfile_num);

+ m_blockfile_info.resize(max_blockfile_num + 1);

+ LogPrintf("%s: last block file = %i\n", __func__, max_blockfile_num);

+ for (int nFile = 0; nFile <= max_blockfile_num; nFile++) {

+ LogPrintf("%s: last block file info: %s\n", __func__, m_blockfile_info[max_blockfile_num].ToString());

+ for (int nFile = max_blockfile_num + 1; true; nFile++) {

+ if (OpenBlockFile(pos, true).IsNull()) {

+ {

+ // Initialize the blockfile cursors.

+ LOCK(cs_LastBlockFile);

+ for (size_t i = 0; i < m_blockfile_info.size(); ++i) {

+ const auto last_height_in_file = m_blockfile_info[i].nHeightLast;

+ m_blockfile_cursors[BlockfileTypeForHeight(last_height_in_file)] = {static_cast<int>(i), 0};

+ }

+ }

+

+ int max_blockfile = WITH_LOCK(cs_LastBlockFile, return this->MaxBlockfileNum());

+ for (int file_number = 0; file_number < max_blockfile; file_number++) {

+ CAutoFile fileout{OpenUndoFile(pos)};

+ CAutoFile filein{OpenUndoFile(pos, true)};

+bool BlockManager::FlushUndoFile(int block_file, bool finalize)

+ return false;

+ return true;

+bool BlockManager::FlushBlockFile(int blockfile_num, bool fFinalize, bool finalize_undo)

+ bool success = true;

+ return true;

+ assert(static_cast<int>(m_blockfile_info.size()) > blockfile_num);

+ FlatFilePos block_pos_old(blockfile_num, m_blockfile_info[blockfile_num].nSize);

+ success = false;

+ if (!fFinalize || finalize_undo) {

+ if (!FlushUndoFile(blockfile_num, finalize_undo)) {

+ success = false;

+ }

+ }

+ return success;

+}

+

+BlockfileType BlockManager::BlockfileTypeForHeight(int height)

+{

+ if (!m_snapshot_height) {

+ return BlockfileType::NORMAL;

+ }

+ return (height >= *m_snapshot_height) ? BlockfileType::ASSUMED : BlockfileType::NORMAL;

+}

+

+bool BlockManager::FlushChainstateBlockFile(int tip_height)

+{

+ LOCK(cs_LastBlockFile);

+ auto& cursor = m_blockfile_cursors[BlockfileTypeForHeight(tip_height)];

+ if (cursor) {

+ // The cursor may not exist after a snapshot has been loaded but before any

+ // blocks have been downloaded.

+ return FlushBlockFile(cursor->file_num, /*fFinalize=*/false, /*finalize_undo=*/false);

+ }

+ return false;

+CAutoFile BlockManager::OpenBlockFile(const FlatFilePos& pos, bool fReadOnly) const

+ return CAutoFile{BlockFileSeq().Open(pos, fReadOnly), CLIENT_VERSION};

+CAutoFile BlockManager::OpenUndoFile(const FlatFilePos& pos, bool fReadOnly) const

+ return CAutoFile{UndoFileSeq().Open(pos, fReadOnly), CLIENT_VERSION};

+ const BlockfileType chain_type = BlockfileTypeForHeight(nHeight);

+

+ if (!m_blockfile_cursors[chain_type]) {

+ // If a snapshot is loaded during runtime, we may not have initialized this cursor yet.

+ assert(chain_type == BlockfileType::ASSUMED);

+ const auto new_cursor = BlockfileCursor{this->MaxBlockfileNum() + 1};

+ m_blockfile_cursors[chain_type] = new_cursor;

+ LogPrint(BCLog::BLOCKSTORAGE, "[%s] initializing blockfile cursor to %s\n", chain_type, new_cursor);

+ }

+ const int last_blockfile = m_blockfile_cursors[chain_type]->file_num;

+

+ int nFile = fKnown ? pos.nFile : last_blockfile;

+ if (static_cast<int>(m_blockfile_info.size()) <= nFile) {

+

+ finalize_undo = (static_cast<int>(m_blockfile_info[nFile].nHeightLast) ==

+ Assert(m_blockfile_cursors[chain_type])->undo_height);

+

+ // Try the next unclaimed blockfile number

+ nFile = this->MaxBlockfileNum() + 1;

+ // Set to increment MaxBlockfileNum() for next iteration

+ m_blockfile_cursors[chain_type] = BlockfileCursor{nFile};

+

+ if (static_cast<int>(m_blockfile_info.size()) <= nFile) {

+ if (nFile != last_blockfile) {

+ LogPrint(BCLog::BLOCKSTORAGE, "Leaving block file %i: %s (onto %i) (height %i)\n",

+ last_blockfile, m_blockfile_info[last_blockfile].ToString(), nFile, nHeight);

+ }

+

+ // Do not propagate the return code. The flush concerns a previous block

+ // and undo file that has already been written to. If a flush fails

+ // here, and we crash, there is no expected additional block data

+ // inconsistency arising from the flush failure here. However, the undo

+ // data may be inconsistent after a crash if the flush is called during

+ // a reindex. A flush error might also leave some of the data files

+ // untrimmed.

+ if (!FlushBlockFile(last_blockfile, !fKnown, finalize_undo)) {

+ LogPrintLevel(BCLog::BLOCKSTORAGE, BCLog::Level::Warning,

+ "Failed to flush previous block file %05i (finalize=%i, finalize_undo=%i) before opening new block file %05i\n",

+ last_blockfile, !fKnown, finalize_undo, nFile);

+ // No undo data yet in the new file, so reset our undo-height tracking.

+ m_blockfile_cursors[chain_type] = BlockfileCursor{nFile};

+ CAutoFile fileout{OpenBlockFile(pos)};

+ const BlockfileType type = BlockfileTypeForHeight(block.nHeight);

+ auto& cursor = *Assert(WITH_LOCK(cs_LastBlockFile, return m_blockfile_cursors[type]));

+

+ if (_pos.nFile < cursor.file_num && static_cast<uint32_t>(block.nHeight) == m_blockfile_info[_pos.nFile].nHeightLast) {

+ // Do not propagate the return code, a failed flush here should not

+ // be an indication for a failed write. If it were propagated here,

+ // the caller would assume the undo data not to be written, when in

+ // fact it is. Note though, that a failed flush might leave the data

+ // file untrimmed.

+ if (!FlushUndoFile(_pos.nFile, true)) {

+ LogPrintLevel(BCLog::BLOCKSTORAGE, BCLog::Level::Warning, "Failed to flush undo file %05i\n", _pos.nFile);

+ }

+ } else if (_pos.nFile == cursor.file_num && block.nHeight > cursor.undo_height) {

+ cursor.undo_height = block.nHeight;

+ CAutoFile filein{OpenBlockFile(pos, true)};

+ CAutoFile filein{OpenBlockFile(hpos, true)};

+ CAutoFile file{chainman.m_blockman.OpenBlockFile(pos, true)};

+ if (file.IsNull()) {

+ CAutoFile file{fsbridge::fopen(path, "rb"), CLIENT_VERSION};

+ if (!file.IsNull()) {

+

+std::ostream& operator<<(std::ostream& os, const BlockfileType& type) {

+ switch(type) {

+ case BlockfileType::NORMAL: os << "normal"; break;

+ case BlockfileType::ASSUMED: os << "assumed"; break;

+ default: os.setstate(std::ios_base::failbit);

+ }

+ return os;

+}

+

+std::ostream& operator<<(std::ostream& os, const BlockfileCursor& cursor) {

+ os << strprintf("BlockfileCursor(file_num=%d, undo_height=%d)", cursor.file_num, cursor.undo_height);

+ return os;

+}

+#include <kernel/chain.h>

+class CAutoFile;

+enum BlockfileType {

+ // Values used as array indexes - do not change carelessly.

+ NORMAL = 0,

+ ASSUMED = 1,

+ NUM_TYPES = 2,

+};

+

+std::ostream& operator<<(std::ostream& os, const BlockfileType& type);

+

+struct BlockfileCursor {

+ // The latest blockfile number.

+ int file_num{0};

+

+ // Track the height of the highest block in file_num whose undo

+ // data has been written. Block data is written to block files in download

+ // order, but is written to undo files in validation order, which is

+ // usually in order by height. To avoid wasting disk space, undo files will

+ // be trimmed whenever the corresponding block file is finalized and

+ // the height of the highest block written to the block file equals the

+ // height of the highest block written to the undo file. This is a

+ // heuristic and can sometimes preemptively trim undo files that will write

+ // more data later, and sometimes fail to trim undo files that can't have

+ // more data written later.

+ int undo_height{0};

+};

+

+std::ostream& operator<<(std::ostream& os, const BlockfileCursor& cursor);

+

+

+ bool LoadBlockIndex(const std::optional<uint256>& snapshot_blockhash)

+

+ /** Return false if block file or undo file flushing fails. */

+ [[nodiscard]] bool FlushBlockFile(int blockfile_num, bool fFinalize, bool finalize_undo);

+

+ /** Return false if undo file flushing fails. */

+ [[nodiscard]] bool FlushUndoFile(int block_file, bool finalize = false);

+

+ [[nodiscard]] bool FindBlockPos(FlatFilePos& pos, unsigned int nAddSize, unsigned int nHeight, uint64_t nTime, bool fKnown);

+ [[nodiscard]] bool FlushChainstateBlockFile(int tip_height);

+ CAutoFile OpenUndoFile(const FlatFilePos& pos, bool fReadOnly = false) const;

+ void FindFilesToPruneManual(

+ std::set<int>& setFilesToPrune,

+ int nManualPruneHeight,

+ const Chainstate& chain,

+ ChainstateManager& chainman);

+ * @param last_prune The last height we're able to prune, according to the prune locks

+ void FindFilesToPrune(

+ std::set<int>& setFilesToPrune,

+ int last_prune,

+ const Chainstate& chain,

+ ChainstateManager& chainman);

+ //! Since assumedvalid chainstates may be syncing a range of the chain that is very

+ //! far away from the normal/background validation process, we should segment blockfiles

+ //! for assumed chainstates. Otherwise, we might have wildly different height ranges

+ //! mixed into the same block files, which would impair our ability to prune

+ //! effectively.

+ //!

+ //! This data structure maintains separate blockfile number cursors for each

+ //! BlockfileType. The ASSUMED state is initialized, when necessary, in FindBlockPos().

+ //!

+ //! The first element is the NORMAL cursor, second is ASSUMED.

+ std::array<std::optional<BlockfileCursor>, BlockfileType::NUM_TYPES>

+ m_blockfile_cursors GUARDED_BY(cs_LastBlockFile) = {

+ BlockfileCursor{},

+ std::nullopt,

+ };

+ int MaxBlockfileNum() const EXCLUSIVE_LOCKS_REQUIRED(cs_LastBlockFile)

+ {

+ static const BlockfileCursor empty_cursor;

+ const auto& normal = m_blockfile_cursors[BlockfileType::NORMAL].value_or(empty_cursor);

+ const auto& assumed = m_blockfile_cursors[BlockfileType::ASSUMED].value_or(empty_cursor);

+ return std::max(normal.file_num, assumed.file_num);

+ }

+ BlockfileType BlockfileTypeForHeight(int height);

+

+ /**

+ * The height of the base block of an assumeutxo snapshot, if one is in use.

+ *

+ * This controls how blockfiles are segmented by chainstate type to avoid

+ * comingling different height regions of the chain when an assumedvalid chainstate

+ * is in use. If heights are drastically different in the same blockfile, pruning

+ * suffers.

+ *

+ * This is set during ActivateSnapshot() or upon LoadBlockIndex() if a snapshot

+ * had been previously loaded. After the snapshot is validated, this is unset to

+ * restore normal LoadBlockIndex behavior.

+ */

+ std::optional<int> m_snapshot_height;

+

+ bool LoadBlockIndexDB(const std::optional<uint256>& snapshot_blockhash)

+ EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

+ CAutoFile OpenBlockFile(const FlatFilePos& pos, bool fReadOnly = false) const;

+ bool has_snapshot = chainman.DetectSnapshotChainstate(options.mempool);

+

+ if (has_snapshot && (options.reindex || options.reindex_chainstate)) {

+ LogPrintf("[snapshot] deleting snapshot chainstate due to reindexing\n");

+ if (!chainman.DeleteSnapshotChainstate()) {

+ return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated("Couldn't remove snapshot chainstate.")};

+ }

+ }

+

+std::string TransportTypeAsString(TransportProtocolType transport_type)

+{

+ switch (transport_type) {

+ case TransportProtocolType::DETECTING:

+ return "detecting";

+ case TransportProtocolType::V1:

+ return "v1";

+ case TransportProtocolType::V2:

+ return "v2";

+ } // no default case, so the compiler can warn about missing cases

+

+ assert(false);

+}

+#include <stdint.h>

+/** Transport layer version */

+enum class TransportProtocolType : uint8_t {

+ DETECTING, //!< Peer could be v1 or v2

+ V1, //!< Unencrypted, plaintext protocol

+ V2, //!< BIP324 protocol

+};

+

+/** Convert TransportProtocolType enum to a string value */

+std::string TransportTypeAsString(TransportProtocolType transport_type);

+

+#include <node/mini_miner.h>

+ void BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override

+ m_notifications->blockConnected(role, kernel::MakeBlockInfo(index, block.get()));

+ void ChainStateFlushed(ChainstateRole role, const CBlockLocator& locator) override {

+ m_notifications->chainStateFlushed(role, locator);

+ }

+

+ std::map<COutPoint, CAmount> CalculateIndividualBumpFees(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) override

+ {

+ if (!m_node.mempool) {

+ std::map<COutPoint, CAmount> bump_fees;

+ for (const auto& outpoint : outpoints) {

+ bump_fees.emplace(std::make_pair(outpoint, 0));

+ }

+ return bump_fees;

+ }

+ return MiniMiner(*m_node.mempool, outpoints).CalculateBumpFees(target_feerate);

+ }

+

+ std::optional<CAmount> CalculateCombinedBumpFee(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) override

+ {

+ if (!m_node.mempool) {

+ return 0;

+ }

+ return MiniMiner(*m_node.mempool, outpoints).CalculateTotalBumpFees(target_feerate);

+ }

+ Assume(descendant->second.GetSizeWithAncestors() >= anc->second.GetTxSize());

+ descendant->second.UpdateAncestorState(-anc->second.GetTxSize(), -anc->second.GetModifiedFee());

+ CAmount fee_with_ancestors;

+ int64_t vsize_with_ancestors;

+

+ void UpdateAncestorState(int64_t vsize_change, CAmount fee_change) {

+ vsize_with_ancestors += vsize_change;

+ fee_with_ancestors += fee_change;

+ }

+ const int64_t total_weight = std::accumulate(txns.cbegin(), txns.cend(), 0,

+ [](int64_t sum, const auto& tx) { return sum + GetTransactionWeight(*tx); });

+ // If the package only contains 1 tx, it's better to report the policy violation on individual tx weight.

+ if (package_count > 1 && total_weight > MAX_PACKAGE_WEIGHT) {

+/** Default maximum total weight of transactions in a package in weight

+ to allow for context-less checks. This must allow a superset of sigops

+ weighted vsize limited transactions to not disallow transactions we would

+ have otherwise accepted individually. */

+static constexpr uint32_t MAX_PACKAGE_WEIGHT = 404'000;

+static_assert(MAX_PACKAGE_WEIGHT >= MAX_STANDARD_TX_WEIGHT);

+// If a package is to be evaluated, it must be at least as large as the mempool's ancestor/descendant limits,

+// otherwise transactions that would be individually accepted may be rejected in a package erroneously.

+// Since a submitted package must be child-with-unconfirmed-parents (all of the transactions are an ancestor

+static_assert(MAX_PACKAGE_WEIGHT >= DEFAULT_ANCESTOR_SIZE_LIMIT_KVB * WITNESS_SCALE_FACTOR * 1000);

+static_assert(MAX_PACKAGE_WEIGHT >= DEFAULT_DESCENDANT_SIZE_LIMIT_KVB * WITNESS_SCALE_FACTOR * 1000);

+ * 2. The total weight cannot exceed MAX_PACKAGE_WEIGHT.

+ return (CHashWriter{PROTOCOL_VERSION} << *this).GetHash();

+ return (CHashWriter{SERIALIZE_TRANSACTION_NO_WITNESS} << *this).GetHash();

+ return (CHashWriter{SERIALIZE_TRANSACTION_NO_WITNESS} << *this).GetHash();

+ return (CHashWriter{0} << *this).GetHash();

+ case NODE_P2P_V2: return "P2P_V2";

+ // NODE_P2P_V2 means the node supports BIP324 transport

+ NODE_P2P_V2 = (1 << 11),

+

+ SER_PARAMS_OPFUNC

+ OverrideStream<Stream> os{&s, s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS};

+ CVectorWriter s_value{s.GetVersion(), value, 0};

+ SpanReader skey{s.GetVersion(), key};

+ OverrideStream<Stream> os{&s, s.GetVersion() & ~SERIALIZE_TRANSACTION_NO_WITNESS};

+ SpanReader s_key{s.GetVersion(), Span{key}.subspan(1)};

+ SpanReader s_key{s.GetVersion(), Span{key}.subspan(1)};

+ CVectorWriter s_value{s.GetVersion(), value, 0};

+ CVectorWriter s_value{s.GetVersion(), value, 0};

+ SpanReader skey{s.GetVersion(), key};

+ SpanReader s_tree{s.GetVersion(), tree_v};

+ OverrideStream<Stream> os{&s, s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS};

+ SpanReader skey{s.GetVersion(), key};

+ OverrideStream<Stream> os{&s, s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS};

+ if (m_passphrase_out) {

+ m_passphrase_out->assign(oldpass);

+ }

+ m_migrate_wallet_action = new QAction(tr("Migrate Wallet"), this);

+ m_migrate_wallet_action->setEnabled(false);

+ m_migrate_wallet_action->setStatusTip(tr("Migrate a wallet"));

+

+ connect(m_migrate_wallet_action, &QAction::triggered, [this] {

+ auto activity = new MigrateWalletActivity(m_wallet_controller, this);

+ connect(activity, &MigrateWalletActivity::migrated, this, &BitcoinGUI::setCurrentWallet);

+ activity->migrate(walletFrame->currentWalletModel());

+ });

+ file->addAction(m_migrate_wallet_action);

+ m_migrate_wallet_action->setEnabled(wallet_model->wallet().isLegacy());

+ m_migrate_wallet_action->setEnabled(enabled);

+ QAction* m_migrate_wallet_action{nullptr};

+ QMenu* m_migrate_wallet_menu{nullptr};

+ ui->blank_wallet_checkbox->setChecked(false);

+ // Wallets without private keys cannot set blank

+ ui->blank_wallet_checkbox->setEnabled(!checked);

+ ui->blank_wallet_checkbox->setChecked(false);

+ // Disable the disable_privkeys_checkbox when blank_wallet_checkbox is checked

+ // as blank-ness only pertains to wallets with private keys.

+ ui->disable_privkeys_checkbox->setEnabled(!checked);

+ if (checked) {

+ ui->disable_privkeys_checkbox->setChecked(false);

+using wallet::ISMINE_NO;

+ bool involvesWatchAddress = false;

+ isminetype fAllFromMe = ISMINE_SPENDABLE;

+ bool any_from_me = false;

+ if (wtx.is_coinbase) {

+ fAllFromMe = ISMINE_NO;

+ } else {

+ if (mine) any_from_me = true;

+ }

+ if (fAllFromMe || !any_from_me) {

+ CAmount nTxFee = nDebit - wtx.tx->GetValueOut();

+ for(unsigned int i = 0; i < wtx.tx->vout.size(); i++)

+ const CTxOut& txout = wtx.tx->vout[i];

+ if (fAllFromMe) {

+ // Change is only really possible if we're the sender

+ // Otherwise, someone just sent bitcoins to a change address, which should be shown

+ if (wtx.txout_is_change[i]) {

+ //

+ // Debit

+ //

+

+ TransactionRecord sub(hash, nTime);

+ sub.idx = i;

+ sub.involvesWatchAddress = involvesWatchAddress;

+

+ if (!std::get_if<CNoDestination>(&wtx.txout_address[i]))

+ sub.address = EncodeDestination(wtx.txout_address[i]);

+

+ isminetype mine = wtx.txout_is_mine[i];

+ if(mine)

+ {

+ //

+ // Credit

+ //

+

+ TransactionRecord sub(hash, nTime);

+ sub.idx = i; // vout index

+ sub.credit = txout.nValue;

+ sub.involvesWatchAddress = mine & ISMINE_WATCH_ONLY;

+ if (wtx.txout_address_is_mine[i])

+ {

+ // Received by Bitcoin Address

+ sub.type = TransactionRecord::RecvWithAddress;

+ sub.address = EncodeDestination(wtx.txout_address[i]);

+ }

+ else

+ {

+ // Received by IP connection (deprecated features), or a multisignature or other non-simple transaction

+ sub.type = TransactionRecord::RecvFromOther;

+ sub.address = mapValue["from"];

+ }

+ if (wtx.is_coinbase)

+ {

+ // Generated

+ sub.type = TransactionRecord::Generated;

+ }

+

+ parts.append(sub);

+ }

+ } else {

+ //

+ // Mixed debit transaction, can't break down payees

+ //

+ parts.append(TransactionRecord(hash, nTime, TransactionRecord::Other, "", nNet, 0));

+ parts.last().involvesWatchAddress = involvesWatchAddress;

+ int typesort;

+ switch (type) {

+ case SendToAddress: case SendToOther:

+ typesort = 2; break;

+ case RecvWithAddress: case RecvFromOther:

+ typesort = 3; break;

+ default:

+ typesort = 9;

+ }

+ status.sortKey = strprintf("%010d-%01d-%010u-%03d-%d",

+ idx,

+ typesort);

+#include <tinyformat.h>

+ return QString::fromStdString(strprintf("%020s-%s", rec->time, rec->status.sortKey));

+

+void MigrateWalletActivity::migrate(WalletModel* wallet_model)

+{

+ // Warn the user about migration

+ QMessageBox box(m_parent_widget);

+ box.setWindowTitle(tr("Migrate wallet"));

+ box.setText(tr("Are you sure you wish to migrate the wallet <i>%1</i>?").arg(GUIUtil::HtmlEscape(wallet_model->getDisplayName())));

+ box.setInformativeText(tr("Migrating the wallet will convert this wallet to one or more descriptor wallets. A new wallet backup will need to be made.\n"

+ "If this wallet contains any watchonly scripts, a new wallet will be created which contains those watchonly scripts.\n"

+ "If this wallet contains any solvable but not watched scripts, a different and new wallet will be created which contains those scripts.\n\n"

+ "The migration process will create a backup of the wallet before migrating. This backup file will be named "

+ "<wallet name>-<timestamp>.legacy.bak and can be found in the directory for this wallet. In the event of "

+ "an incorrect migration, the backup can be restored with the \"Restore Wallet\" functionality."));

+ box.setStandardButtons(QMessageBox::Yes|QMessageBox::Cancel);

+ box.setDefaultButton(QMessageBox::Yes);

+ if (box.exec() != QMessageBox::Yes) return;

+

+ // Get the passphrase if it is encrypted regardless of it is locked or unlocked. We need the passphrase itself.

+ SecureString passphrase;

+ WalletModel::EncryptionStatus enc_status = wallet_model->getEncryptionStatus();

+ if (enc_status == WalletModel::EncryptionStatus::Locked || enc_status == WalletModel::EncryptionStatus::Unlocked) {

+ AskPassphraseDialog dlg(AskPassphraseDialog::Unlock, m_parent_widget, &passphrase);

+ dlg.setModel(wallet_model);

+ dlg.exec();

+ }

+

+ // GUI needs to remove the wallet so that it can actually be unloaded by migration

+ const std::string name = wallet_model->wallet().getWalletName();

+ m_wallet_controller->removeAndDeleteWallet(wallet_model);

+

+ showProgressDialog(tr("Migrate Wallet"), tr("Migrating Wallet <b>%1</b>…").arg(GUIUtil::HtmlEscape(name)));

+

+ QTimer::singleShot(0, worker(), [this, name, passphrase] {

+ auto res{node().walletLoader().migrateWallet(name, passphrase)};

+

+ if (res) {

+ m_success_message = tr("The wallet '%1' was migrated successfully.").arg(GUIUtil::HtmlEscape(res->wallet->getWalletName()));

+ if (res->watchonly_wallet_name) {

+ m_success_message += tr(" Watchonly scripts have been migrated to a new wallet named '%1'.").arg(GUIUtil::HtmlEscape(res->watchonly_wallet_name.value()));

+ }

+ if (res->solvables_wallet_name) {

+ m_success_message += tr(" Solvable but not watched scripts have been migrated to a new wallet named '%1'.").arg(GUIUtil::HtmlEscape(res->solvables_wallet_name.value()));

+ }

+ m_wallet_model = m_wallet_controller->getOrCreateWallet(std::move(res->wallet));

+ } else {

+ m_error_message = util::ErrorString(res);

+ }

+

+ QTimer::singleShot(0, this, &MigrateWalletActivity::finish);

+ });

+}

+

+void MigrateWalletActivity::finish()

+{

+ if (!m_error_message.empty()) {

+ QMessageBox::critical(m_parent_widget, tr("Migration failed"), QString::fromStdString(m_error_message.translated));

+ } else {

+ QMessageBox::information(m_parent_widget, tr("Migration Successful"), m_success_message);

+ }

+

+ if (m_wallet_model) Q_EMIT migrated(m_wallet_model);

+

+ Q_EMIT finished();

+}

+class MigrateWalletActivity;

+ void migrateWallet(WalletModel* wallet_model, QWidget* parent = nullptr);

+

+ friend class MigrateWalletActivity;

+class MigrateWalletActivity : public WalletControllerActivity

+{

+ Q_OBJECT

+

+public:

+ MigrateWalletActivity(WalletController* wallet_controller, QWidget* parent) : WalletControllerActivity(wallet_controller, parent) {}

+

+ void migrate(WalletModel* wallet_model);

+

+Q_SIGNALS:

+ void migrated(WalletModel* wallet_model);

+

+private:

+ QString m_success_message;

+

+ void finish();

+};

+

+ PSHUTDOWNBRCREATE shutdownBRCreate = (PSHUTDOWNBRCREATE)(void*)GetProcAddress(GetModuleHandleA("User32.dll"), "ShutdownBlockReasonCreate");

+#include <clientversion.h>

+static RPCHelpMan loadtxoutset()

+{

+ return RPCHelpMan{

+ "loadtxoutset",

+ "Load the serialized UTXO set from disk.\n"

+ "Once this snapshot is loaded, its contents will be "

+ "deserialized into a second chainstate data structure, which is then used to sync to "

+ "the network's tip under a security model very much like `assumevalid`. "

+ "Meanwhile, the original chainstate will complete the initial block download process in "

+ "the background, eventually validating up to the block that the snapshot is based upon.\n\n"

+

+ "The result is a usable bitcoind instance that is current with the network tip in a "

+ "matter of minutes rather than hours. UTXO snapshot are typically obtained from "

+ "third-party sources (HTTP, torrent, etc.) which is reasonable since their "

+ "contents are always checked by hash.\n\n"

+

+ "You can find more information on this process in the `assumeutxo` design "

+ "document (<https://github.com/bitcoin/bitcoin/blob/master/doc/design/assumeutxo.md>).",

+ {

+ {"path",

+ RPCArg::Type::STR,

+ RPCArg::Optional::NO,

+ "path to the snapshot file. If relative, will be prefixed by datadir."},

+ },

+ RPCResult{

+ RPCResult::Type::OBJ, "", "",

+ {

+ {RPCResult::Type::NUM, "coins_loaded", "the number of coins loaded from the snapshot"},

+ {RPCResult::Type::STR_HEX, "tip_hash", "the hash of the base of the snapshot"},

+ {RPCResult::Type::NUM, "base_height", "the height of the base of the snapshot"},

+ {RPCResult::Type::STR, "path", "the absolute path that the snapshot was loaded from"},

+ }

+ },

+ RPCExamples{

+ HelpExampleCli("loadtxoutset", "utxo.dat")

+ },

+ [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

+{

+ NodeContext& node = EnsureAnyNodeContext(request.context);

+ fs::path path{AbsPathForConfigVal(EnsureArgsman(node), fs::u8path(request.params[0].get_str()))};

+

+ FILE* file{fsbridge::fopen(path, "rb")};

+ AutoFile afile{file};

+ if (afile.IsNull()) {

+ throw JSONRPCError(

+ RPC_INVALID_PARAMETER,

+ "Couldn't open file " + path.u8string() + " for reading.");

+ }

+

+ SnapshotMetadata metadata;

+ afile >> metadata;

+

+ uint256 base_blockhash = metadata.m_base_blockhash;

+ int max_secs_to_wait_for_headers = 60 * 10;

+ CBlockIndex* snapshot_start_block = nullptr;

+

+ LogPrintf("[snapshot] waiting to see blockheader %s in headers chain before snapshot activation\n",

+ base_blockhash.ToString());

+

+ ChainstateManager& chainman = *node.chainman;

+

+ while (max_secs_to_wait_for_headers > 0) {

+ snapshot_start_block = WITH_LOCK(::cs_main,

+ return chainman.m_blockman.LookupBlockIndex(base_blockhash));

+ max_secs_to_wait_for_headers -= 1;

+

+ if (!IsRPCRunning()) {

+ throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");

+ }

+

+ if (!snapshot_start_block) {

+ std::this_thread::sleep_for(std::chrono::seconds(1));

+ } else {

+ break;

+ }

+ }

+

+ if (!snapshot_start_block) {

+ LogPrintf("[snapshot] timed out waiting for snapshot start blockheader %s\n",

+ base_blockhash.ToString());

+ throw JSONRPCError(

+ RPC_INTERNAL_ERROR,

+ "Timed out waiting for base block header to appear in headers chain");

+ }

+ if (!chainman.ActivateSnapshot(afile, metadata, false)) {

+ throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to load UTXO snapshot " + fs::PathToString(path));

+ }

+ CBlockIndex* new_tip{WITH_LOCK(::cs_main, return chainman.ActiveTip())};

+

+ UniValue result(UniValue::VOBJ);

+ result.pushKV("coins_loaded", metadata.m_coins_count);

+ result.pushKV("tip_hash", new_tip->GetBlockHash().ToString());

+ result.pushKV("base_height", new_tip->nHeight);

+ result.pushKV("path", fs::PathToString(path));

+ return result;

+},

+ };

+}

+

+const std::vector<RPCResult> RPCHelpForChainstate{

+ {RPCResult::Type::NUM, "blocks", "number of blocks in this chainstate"},

+ {RPCResult::Type::STR_HEX, "bestblockhash", "blockhash of the tip"},

+ {RPCResult::Type::NUM, "difficulty", "difficulty of the tip"},

+ {RPCResult::Type::NUM, "verificationprogress", "progress towards the network tip"},

+ {RPCResult::Type::STR_HEX, "snapshot_blockhash", /*optional=*/true, "the base block of the snapshot this chainstate is based on, if any"},

+ {RPCResult::Type::NUM, "coins_db_cache_bytes", "size of the coinsdb cache"},

+ {RPCResult::Type::NUM, "coins_tip_cache_bytes", "size of the coinstip cache"},

+};

+

+static RPCHelpMan getchainstates()

+{

+return RPCHelpMan{

+ "getchainstates",

+ "\nReturn information about chainstates.\n",

+ {},

+ RPCResult{

+ RPCResult::Type::OBJ, "", "", {

+ {RPCResult::Type::NUM, "headers", "the number of headers seen so far"},

+ {RPCResult::Type::OBJ, "normal", /*optional=*/true, "fully validated chainstate containing blocks this node has validated starting from the genesis block", RPCHelpForChainstate},

+ {RPCResult::Type::OBJ, "snapshot", /*optional=*/true, "only present if an assumeutxo snapshot is loaded. Partially validated chainstate containing blocks this node has validated starting from the snapshot. After the snapshot is validated (when the 'normal' chainstate advances far enough to validate it), this chainstate will replace and become the 'normal' chainstate.", RPCHelpForChainstate},

+ }

+ },

+ RPCExamples{

+ HelpExampleCli("getchainstates", "")

+ + HelpExampleRpc("getchainstates", "")

+ },

+ [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

+{

+ LOCK(cs_main);

+ UniValue obj(UniValue::VOBJ);

+

+ NodeContext& node = EnsureAnyNodeContext(request.context);

+ ChainstateManager& chainman = *node.chainman;

+

+ auto make_chain_data = [&](const Chainstate& cs) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {

+ AssertLockHeld(::cs_main);

+ UniValue data(UniValue::VOBJ);

+ if (!cs.m_chain.Tip()) {

+ return data;

+ }

+ const CChain& chain = cs.m_chain;

+ const CBlockIndex* tip = chain.Tip();

+

+ data.pushKV("blocks", (int)chain.Height());

+ data.pushKV("bestblockhash", tip->GetBlockHash().GetHex());

+ data.pushKV("difficulty", (double)GetDifficulty(tip));

+ data.pushKV("verificationprogress", GuessVerificationProgress(Params().TxData(), tip));

+ data.pushKV("coins_db_cache_bytes", cs.m_coinsdb_cache_size_bytes);

+ data.pushKV("coins_tip_cache_bytes", cs.m_coinstip_cache_size_bytes);

+ if (cs.m_from_snapshot_blockhash) {

+ data.pushKV("snapshot_blockhash", cs.m_from_snapshot_blockhash->ToString());

+ }

+ return data;

+ };

+

+ if (chainman.GetAll().size() > 1) {

+ for (Chainstate* chainstate : chainman.GetAll()) {

+ obj.pushKV(

+ chainstate->m_from_snapshot_blockhash ? "snapshot" : "normal",

+ make_chain_data(*chainstate));

+ }

+ } else {

+ obj.pushKV("normal", make_chain_data(chainman.ActiveChainstate()));

+ }

+ obj.pushKV("headers", chainman.m_best_header ? chainman.m_best_header->nHeight : -1);

+

+ return obj;

+}

+ };

+}

+

+

+ {"blockchain", &dumptxoutset},

+ {"blockchain", &loadtxoutset},

+ {"blockchain", &getchainstates},

+ { "bumpfee", 1, "original_change_index"},

+ { "psbtbumpfee", 1, "original_change_index"},

+ { "addnode", 2, "v2transport" },

+ if (Params().GetChainType() != ChainType::REGTEST) {

+const std::vector<std::string> TRANSPORT_TYPE_DOC{

+ "detecting (peer could be v1 or v2)",

+ "v1 (plaintext transport protocol)",

+ "v2 (BIP324 encrypted transport protocol)"

+};

+

+ {RPCResult::Type::STR, "transport_protocol_type", "Type of transport protocol: \n" + Join(TRANSPORT_TYPE_DOC, ",\n") + ".\n"},

+ {RPCResult::Type::STR, "session_id", "The session ID for this connection, or \"\" if there is none (\"v2\" transport protocol only).\n"},

+ obj.pushKV("transport_protocol_type", TransportTypeAsString(stats.m_transport_type));

+ obj.pushKV("session_id", stats.m_session_id);

+ {"node", RPCArg::Type::STR, RPCArg::Optional::NO, "The address of the peer to connect to"},

+ {"v2transport", RPCArg::Type::BOOL, RPCArg::Default{false}, "Attempt to connect using BIP324 v2 transport protocol (ignored for 'remove' command)"},

+ HelpExampleCli("addnode", "\"192.168.0.6:8333\" \"onetry\" true")

+ + HelpExampleRpc("addnode", "\"192.168.0.6:8333\", \"onetry\" true")

+ const std::string command{request.params[1].get_str()};

+ if (command != "onetry" && command != "add" && command != "remove") {

+ const std::string node_arg{request.params[0].get_str()};

+ bool use_v2transport = self.Arg<bool>(2);

+

+ if (use_v2transport && !(node.connman->GetLocalServices() & NODE_P2P_V2)) {

+ throw JSONRPCError(RPC_INVALID_PARAMETER, "Error: v2transport requested but not enabled (see -v2transport)");

+ }

+ if (command == "onetry")

+ connman.OpenNetworkConnection(addr, /*fCountFailure=*/false, /*grant_outbound=*/{}, node_arg.c_str(), ConnectionType::MANUAL, use_v2transport);

+ if (command == "add")

+ if (!connman.AddNode({node_arg, use_v2transport})) {

+ else if (command == "remove")

+ if (!connman.RemoveAddedNode(node_arg)) {

+ if (info.m_params.m_added_node == request.params[0].get_str()) {

+ obj.pushKV("addednode", info.m_params.m_added_node);

+static RPCHelpMan getaddrmaninfo()

+{

+ return RPCHelpMan{"getaddrmaninfo",

+ "\nProvides information about the node's address manager by returning the number of "

+ "addresses in the `new` and `tried` tables and their sum for all networks.\n"

+ "This RPC is for testing only.\n",

+ {},

+ RPCResult{

+ RPCResult::Type::OBJ_DYN, "", "json object with network type as keys",

+ {

+ {RPCResult::Type::OBJ, "network", "the network (" + Join(GetNetworkNames(), ", ") + ")",

+ {

+ {RPCResult::Type::NUM, "new", "number of addresses in the new table, which represent potential peers the node has discovered but hasn't yet successfully connected to."},

+ {RPCResult::Type::NUM, "tried", "number of addresses in the tried table, which represent peers the node has successfully connected to in the past."},

+ {RPCResult::Type::NUM, "total", "total number of addresses in both new/tried tables"},

+ }},

+ }

+ },

+ RPCExamples{

+ HelpExampleCli("getaddrmaninfo", "")

+ + HelpExampleRpc("getaddrmaninfo", "")

+ },

+ [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

+ {

+ NodeContext& node = EnsureAnyNodeContext(request.context);

+ if (!node.addrman) {

+ throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Address manager functionality missing or disabled");

+ }

+

+ UniValue ret(UniValue::VOBJ);

+ for (int n = 0; n < NET_MAX; ++n) {

+ enum Network network = static_cast<enum Network>(n);

+ if (network == NET_UNROUTABLE || network == NET_INTERNAL) continue;

+ UniValue obj(UniValue::VOBJ);

+ obj.pushKV("new", node.addrman->Size(network, true));

+ obj.pushKV("tried", node.addrman->Size(network, false));

+ obj.pushKV("total", node.addrman->Size(network));

+ ret.pushKV(GetNetworkName(network), obj);

+ }

+ UniValue obj(UniValue::VOBJ);

+ obj.pushKV("new", node.addrman->Size(std::nullopt, true));

+ obj.pushKV("tried", node.addrman->Size(std::nullopt, false));

+ obj.pushKV("total", node.addrman->Size());

+ ret.pushKV("all_networks", obj);

+ return ret;

+ },

+ };

+}

+

+ {"hidden", &getaddrmaninfo},

+ // ExtractDestination no longer returns true for P2PK since it doesn't have a corresponding address

+ // However combo will output P2PK and should just ignore that script

+ if (scripts.size() > 1 && std::get_if<PubKeyDestination>(&dest)) {

+ continue;

+ }

+ {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "The hex-encoded network transaction if complete"},

+ if (complete) {

+ CMutableTransaction mtx;

+ PartiallySignedTransaction psbtx_copy = psbtx;

+ CHECK_NONFATAL(FinalizeAndExtractPSBT(psbtx_copy, mtx));

+ CDataStream ssTx_final(SER_NETWORK, PROTOCOL_VERSION);

+ ssTx_final << mtx;

+ result.pushKV("hex", HexStr(ssTx_final));

+ }

+ UniValue operator()(const PubKeyDestination& dest) const

+ {

+ return UniValue(UniValue::VOBJ);

+ }

+

+ obj.pushKV("witness_version", id.GetWitnessVersion());

+ obj.pushKV("witness_program", HexStr(id.GetWitnessProgram()));

+TMPL_INST(CheckRequiredOrDefault, bool, CHECK_NONFATAL(maybe_arg)->get_bool(););

+#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))

+#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, typename std::remove_const<Type>::type& obj) { code; })

+#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })

+/**

+ * Support for (un)serializing many things at once

+ */

+

+template <typename Stream, typename... Args>

+void SerializeMany(Stream& s, const Args&... args)

+{

+ (::Serialize(s, args), ...);

+}

+

+template <typename Stream, typename... Args>

+inline void UnserializeMany(Stream& s, Args&&... args)

+{

+ (::Unserialize(s, args), ...);

+}

+ static constexpr bool ForRead() { return false; }

+

+ template<typename Stream, typename... Args>

+ static void SerReadWriteMany(Stream& s, const Args&... args)

+ {

+ ::SerializeMany(s, args...);

+ }

+

+ template<typename Stream, typename Type, typename Fn>

+ static void SerRead(Stream& s, Type&&, Fn&&)

+ {

+ }

+

+ template<typename Stream, typename Type, typename Fn>

+ static void SerWrite(Stream& s, Type&& obj, Fn&& fn)

+ {

+ fn(s, std::forward<Type>(obj));

+ }

+ static constexpr bool ForRead() { return true; }

+ template<typename Stream, typename... Args>

+ static void SerReadWriteMany(Stream& s, Args&&... args)

+ {

+ ::UnserializeMany(s, args...);

+ }

+

+ template<typename Stream, typename Type, typename Fn>

+ static void SerRead(Stream& s, Type&& obj, Fn&& fn)

+ {

+ fn(s, std::forward<Type>(obj));

+ }

+

+ template<typename Stream, typename Type, typename Fn>

+ static void SerWrite(Stream& s, Type&&, Fn&&)

+ {

+ }

+};

+ T& m_object;

+ explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}

+ return ParamsWrapper<Params, T>{params, t};

+/**

+ * Helper macro for SerParams structs

+ *

+ * Allows you define SerParams instances and then apply them directly

+ * to an object via function call syntax, eg:

+ *

+ * constexpr SerParams FOO{....};

+ * ss << FOO(obj);

+ */

+#define SER_PARAMS_OPFUNC \

+ template <typename T> \

+ auto operator()(T&& t) const { return WithParams(*this, t); }

+

+ SpanReader v{INIT_PROTO_VERSION, signet_solution};

+ CVectorWriter writer{INIT_PROTO_VERSION, block_data, 0};

+ OverrideStream(Stream* stream_, int nVersion_) : stream{stream_}, nVersion{nVersion_} {}

+ CVectorWriter(int nVersionIn, std::vector<unsigned char>& vchDataIn, size_t nPosIn) : nVersion{nVersionIn}, vchData{vchDataIn}, nPos{nPosIn}

+ CVectorWriter(int nVersionIn, std::vector<unsigned char>& vchDataIn, size_t nPosIn, Args&&... args) : CVectorWriter{nVersionIn, vchDataIn, nPosIn}

+

+ SpanReader(int version, Span<const unsigned char> data)

+ : m_version{version}, m_data{data} {}

+/** Wrapper around a CAutoFile& that implements a ring buffer to

+ CAutoFile& m_src;

+ size_t nBytes{m_src.detail_fread(Span{vchBuf}.subspan(pos, readNow))};

+ throw std::ios_base::failure{m_src.feof() ? "BufferedFile::Fill: end of file" : "BufferedFile::Fill: fread failed"};

+ BufferedFile(CAutoFile& file, uint64_t nBufSize, uint64_t nRewindIn)

+ : m_src{file}, nReadLimit{std::numeric_limits<uint64_t>::max()}, nRewind{nRewindIn}, vchBuf(nBufSize, std::byte{0})

+ int GetVersion() const { return m_src.GetVersion(); }

+ return m_read_pos == nSrcPos && m_src.feof();

+template<typename T>

+struct SecureUniqueDeleter {

+ void operator()(T* t) noexcept {

+ secure_allocator<T>().deallocate(t, 1);

+ }

+};

+

+template<typename T>

+using secure_unique_ptr = std::unique_ptr<T, SecureUniqueDeleter<T>>;

+

+template<typename T, typename... Args>

+secure_unique_ptr<T> make_secure_unique(Args&&... as)

+{

+ T* p = secure_allocator<T>().allocate(1);

+

+ // initialize in place, and return as secure_unique_ptr

+ try {

+ return secure_unique_ptr<T>(new (p) T(std::forward(as)...));

+ } catch (...) {

+ secure_allocator<T>().deallocate(p, 1);

+ throw;

+ }

+}

+

+/** An implementation of a semaphore.

+ *

+ * See https://en.wikipedia.org/wiki/Semaphore_(programming)

+ */

+ explicit CSemaphore(int init) noexcept : value(init) {}

+ // Disallow default construct, copy, move.

+ CSemaphore() = delete;

+ CSemaphore(const CSemaphore&) = delete;

+ CSemaphore(CSemaphore&&) = delete;

+ CSemaphore& operator=(const CSemaphore&) = delete;

+ CSemaphore& operator=(CSemaphore&&) = delete;

+

+ void wait() noexcept

+ bool try_wait() noexcept

+ if (value < 1) {

+ }

+ void post() noexcept

+ void Acquire() noexcept

+ if (fHaveGrant) {

+ }

+ void Release() noexcept

+ if (!fHaveGrant) {

+ }

+ bool TryAcquire() noexcept

+ if (!fHaveGrant && sem->try_wait()) {

+ }

+ // Disallow copy.

+ CSemaphoreGrant(const CSemaphoreGrant&) = delete;

+ CSemaphoreGrant& operator=(const CSemaphoreGrant&) = delete;

+

+ // Allow move.

+ CSemaphoreGrant(CSemaphoreGrant&& other) noexcept

+ {

+ sem = other.sem;

+ fHaveGrant = other.fHaveGrant;

+ other.fHaveGrant = false;

+ other.sem = nullptr;

+ }

+

+ CSemaphoreGrant& operator=(CSemaphoreGrant&& other) noexcept

+ Release();

+ sem = other.sem;

+ fHaveGrant = other.fHaveGrant;

+ other.fHaveGrant = false;

+ other.sem = nullptr;

+ return *this;

+ CSemaphoreGrant() noexcept : sem(nullptr), fHaveGrant(false) {}

+ explicit CSemaphoreGrant(CSemaphore& sema, bool fTry = false) noexcept : sem(&sema), fHaveGrant(false)

+ if (fTry) {

+ } else {

+ }

+ explicit operator bool() const noexcept

+ s << CAddress::V1_DISK(info);

+#include <primitives/block.h>

+#include <test/util/logging.h>

+ BOOST_CHECK(!blockman.OpenBlockFile(pos, true).IsNull());

+ BOOST_CHECK(blockman.OpenBlockFile(pos, true).IsNull());

+ BOOST_CHECK(!blockman.OpenBlockFile(new_pos, true).IsNull());

+BOOST_AUTO_TEST_CASE(blockmanager_flush_block_file)

+{

+ KernelNotifications notifications{m_node.exit_status};

+ node::BlockManager::Options blockman_opts{

+ .chainparams = Params(),

+ .blocks_dir = m_args.GetBlocksDirPath(),

+ .notifications = notifications,

+ };

+ BlockManager blockman{m_node.kernel->interrupt, blockman_opts};

+

+ // Test blocks with no transactions, not even a coinbase

+ CBlock block1;

+ block1.nVersion = 1;

+ CBlock block2;

+ block2.nVersion = 2;

+ CBlock block3;

+ block3.nVersion = 3;

+

+ // They are 80 bytes header + 1 byte 0x00 for vtx length

+ constexpr int TEST_BLOCK_SIZE{81};

+

+ // Blockstore is empty

+ BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), 0);

+

+ // Write the first block; dbp=nullptr means this block doesn't already have a disk

+ // location, so allocate a free location and write it there.

+ FlatFilePos pos1{blockman.SaveBlockToDisk(block1, /*nHeight=*/1, /*dbp=*/nullptr)};

+

+ // Write second block

+ FlatFilePos pos2{blockman.SaveBlockToDisk(block2, /*nHeight=*/2, /*dbp=*/nullptr)};

+

+ // Two blocks in the file

+ BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), (TEST_BLOCK_SIZE + BLOCK_SERIALIZATION_HEADER_SIZE) * 2);

+

+ // First two blocks are written as expected

+ // Errors are expected because block data is junk, thrown AFTER successful read

+ CBlock read_block;

+ BOOST_CHECK_EQUAL(read_block.nVersion, 0);

+ {

+ ASSERT_DEBUG_LOG("ReadBlockFromDisk: Errors in block header");

+ BOOST_CHECK(!blockman.ReadBlockFromDisk(read_block, pos1));

+ BOOST_CHECK_EQUAL(read_block.nVersion, 1);

+ }

+ {

+ ASSERT_DEBUG_LOG("ReadBlockFromDisk: Errors in block header");

+ BOOST_CHECK(!blockman.ReadBlockFromDisk(read_block, pos2));

+ BOOST_CHECK_EQUAL(read_block.nVersion, 2);

+ }

+

+ // When FlatFilePos* dbp is given, SaveBlockToDisk() will not write or

+ // overwrite anything to the flat file block storage. It will, however,

+ // update the blockfile metadata. This is to facilitate reindexing

+ // when the user has the blocks on disk but the metadata is being rebuilt.

+ // Verify this behavior by attempting (and failing) to write block 3 data

+ // to block 2 location.

+ CBlockFileInfo* block_data = blockman.GetBlockFileInfo(0);

+ BOOST_CHECK_EQUAL(block_data->nBlocks, 2);

+ BOOST_CHECK(blockman.SaveBlockToDisk(block3, /*nHeight=*/3, /*dbp=*/&pos2) == pos2);

+ // Metadata is updated...

+ BOOST_CHECK_EQUAL(block_data->nBlocks, 3);

+ // ...but there are still only two blocks in the file

+ BOOST_CHECK_EQUAL(blockman.CalculateCurrentUsage(), (TEST_BLOCK_SIZE + BLOCK_SERIALIZATION_HEADER_SIZE) * 2);

+

+ // Block 2 was not overwritten:

+ // SaveBlockToDisk() did not call WriteBlockToDisk() because `FlatFilePos* dbp` was non-null

+ blockman.ReadBlockFromDisk(read_block, pos2);

+ BOOST_CHECK_EQUAL(read_block.nVersion, 2);

+}

+

+ ValidationInterfaceTest::BlockConnected(ChainstateRole::NORMAL, index, new_block, new_block_index);