From c294457b5295789b9d3ff67ed2de8632928a3671 Mon Sep 17 00:00:00 2001
From: Kittywhiskers Van Gogh <63189531+kwvg@users.noreply.github.com>
Date: Wed, 26 Jun 2024 10:56:02 +0000
Subject: [PATCH] merge bitcoin#20295: getblockfrompeer

---
 src/Makefile.am                         |   3 +-
 src/net_processing.cpp                  |  34 +++++++
 src/net_processing.h                    |  10 ++
 src/rest.cpp                            |   1 +
 src/rpc/blockchain.cpp                  | 117 ++++++++++++------------
 src/rpc/blockchain.h                    |  14 ---
 src/rpc/client.cpp                      |   1 +
 src/rpc/coinjoin.cpp                    |   2 +-
 src/rpc/evo.cpp                         |   1 +
 src/rpc/governance.cpp                  |   2 +-
 src/rpc/masternode.cpp                  |   2 +-
 src/rpc/mining.cpp                      |   2 +-
 src/rpc/misc.cpp                        |   2 +-
 src/rpc/net.cpp                         |  19 +---
 src/rpc/net.h                           |  15 ---
 src/rpc/quorums.cpp                     |   2 +-
 src/rpc/rawtransaction.cpp              |   1 +
 src/rpc/server.cpp                      |   1 +
 src/rpc/server_util.cpp                 |  93 +++++++++++++++++++
 src/rpc/server_util.h                   |  30 ++++++
 src/validation.cpp                      |   1 +
 test/functional/rpc_getblockfrompeer.py |  76 +++++++++++++++
 test/functional/test_runner.py          |   1 +
 23 files changed, 315 insertions(+), 115 deletions(-)
 delete mode 100644 src/rpc/net.h
 create mode 100644 src/rpc/server_util.cpp
 create mode 100644 src/rpc/server_util.h
 create mode 100755 test/functional/rpc_getblockfrompeer.py

diff --git a/src/Makefile.am b/src/Makefile.am
index d63dff71cf..c5d69a6c0a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -287,12 +287,12 @@ BITCOIN_CORE_H = \
   rpc/blockchain.h \
   rpc/client.h \
   rpc/mining.h \
-  rpc/net.h \
   rpc/protocol.h \
   rpc/rawtransaction_util.h \
   rpc/register.h \
   rpc/request.h \
   rpc/server.h \
+  rpc/server_util.h \
   rpc/util.h \
   saltedhasher.h \
   scheduler.h \
@@ -510,6 +510,7 @@ libbitcoin_server_a_SOURCES = \
   rpc/quorums.cpp \
   rpc/rawtransaction.cpp \
   rpc/server.cpp \
+  rpc/server_util.cpp \
   script/sigcache.cpp \
   shutdown.cpp \
   spork.cpp \
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 0504616f38..d36d0c472c 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -398,6 +398,7 @@ public:
 
     /** Implement PeerManager */
     void CheckForStaleTipAndEvictPeers() override;
+    bool FetchBlock(NodeId id, const uint256& hash, const CBlockIndex& index) override;
     bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) const override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);
     bool IgnoresIncomingTxs() override { return m_ignore_incoming_txs; }
     void SendPings() override EXCLUSIVE_LOCKS_REQUIRED(!m_peer_mutex);;
@@ -1862,6 +1863,39 @@ bool PeerManagerImpl::BlockRequestAllowed(const CBlockIndex* pindex)
         (GetBlockProofEquivalentTime(*pindexBestHeader, *pindex, *pindexBestHeader, m_chainparams.GetConsensus()) < STALE_RELAY_AGE_LIMIT);
 }
 
+bool PeerManagerImpl::FetchBlock(NodeId id, const uint256& hash, const CBlockIndex& index)
+{
+    if (fImporting || fReindex) return false;
+
+    LOCK(cs_main);
+    // Ensure this peer exists and hasn't been disconnected
+    CNodeState* state = State(id);
+    if (state == nullptr) return false;
+
+    // Mark block as in-flight unless it already is
+    if (!MarkBlockAsInFlight(id, index.GetBlockHash(), &index)) return false;
+
+    // Construct message to request the block
+    std::vector<CInv> invs{CInv(MSG_BLOCK, hash)};
+
+    // Send block request message to the peer
+    bool success = m_connman.ForNode(id, [this, &invs](CNode* node) {
+        const CNetMsgMaker msgMaker(node->GetCommonVersion());
+        this->m_connman.PushMessage(node, msgMaker.Make(NetMsgType::GETDATA, invs));
+        return true;
+    });
+
+    if (success) {
+        LogPrint(BCLog::NET, "Requesting block %s from peer=%d\n",
+                 hash.ToString(), id);
+    } else {
+        MarkBlockAsReceived(hash);
+        LogPrint(BCLog::NET, "Failed to request block %s from peer=%d\n",
+                 hash.ToString(), id);
+    }
+    return success;
+}
+
 std::unique_ptr<PeerManager> PeerManager::make(const CChainParams& chainparams, CConnman& connman, AddrMan& addrman, BanMan* banman,
                                                CScheduler &scheduler, ChainstateManager& chainman, CTxMemPool& pool,
                                                CMasternodeMetaMan& mn_metaman, CMasternodeSync& mn_sync,
diff --git a/src/net_processing.h b/src/net_processing.h
index 8c575a3e64..20e11f98cf 100644
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -66,6 +66,16 @@ public:
                                              const std::unique_ptr<LLMQContext>& llmq_ctx, bool ignore_incoming_txs);
     virtual ~PeerManager() { }
 
+    /**
+     * Attempt to manually fetch block from a given peer. We must already have the header.
+     *
+     * @param[in]  id       The peer id
+     * @param[in]  hash     The block hash
+     * @param[in]  pindex   The blockindex
+     * @returns             Whether a request was successfully made
+     */
+    virtual bool FetchBlock(NodeId id, const uint256& hash, const CBlockIndex& pindex) = 0;
+
     /** Get statistics from node state */
     virtual bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats) const = 0;
 
diff --git a/src/rest.cpp b/src/rest.cpp
index afae27398f..3665e82741 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -19,6 +19,7 @@
 #include <rpc/blockchain.h>
 #include <rpc/protocol.h>
 #include <rpc/server.h>
+#include <rpc/server_util.h>
 #include <streams.h>
 #include <sync.h>
 #include <txmempool.h>
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 3123d8c8bc..940f44e1fb 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -22,6 +22,8 @@
 #include <llmq/context.h>
 #include <node/blockstorage.h>
 #include <node/coinstats.h>
+#include <net.h>
+#include <net_processing.h>
 #include <node/context.h>
 #include <node/utxo_snapshot.h>
 #include <policy/feerate.h>
@@ -29,6 +31,7 @@
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
+#include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <streams.h>
@@ -73,67 +76,6 @@ static CUpdatedBlock latestblock GUARDED_BY(cs_blockchange);
 
 extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, CTxMemPool& mempool, CChainState& active_chainstate, llmq::CChainLocksHandler& clhandler, llmq::CInstantSendManager& isman, UniValue& entry);
 
-NodeContext& EnsureAnyNodeContext(const CoreContext& context)
-{
-    auto* const node_context = GetContext<NodeContext>(context);
-    if (!node_context) {
-        throw JSONRPCError(RPC_INTERNAL_ERROR, "Node context not found");
-    }
-    return *node_context;
-}
-
-CTxMemPool& EnsureMemPool(const NodeContext& node)
-{
-    if (!node.mempool) {
-        throw JSONRPCError(RPC_CLIENT_MEMPOOL_DISABLED, "Mempool disabled or instance not found");
-    }
-    return *node.mempool;
-}
-
-CTxMemPool& EnsureAnyMemPool(const CoreContext& context)
-{
-    return EnsureMemPool(EnsureAnyNodeContext(context));
-}
-
-ChainstateManager& EnsureChainman(const NodeContext& node)
-{
-    if (!node.chainman) {
-        throw JSONRPCError(RPC_INTERNAL_ERROR, "Node chainman not found");
-    }
-    return *node.chainman;
-}
-
-ChainstateManager& EnsureAnyChainman(const CoreContext& context)
-{
-    return EnsureChainman(EnsureAnyNodeContext(context));
-}
-
-CBlockPolicyEstimator& EnsureFeeEstimator(const NodeContext& node)
-{
-    if (!node.fee_estimator) {
-        throw JSONRPCError(RPC_INTERNAL_ERROR, "Fee estimation disabled");
-    }
-    return *node.fee_estimator;
-}
-
-CBlockPolicyEstimator& EnsureAnyFeeEstimator(const CoreContext& context)
-{
-    return EnsureFeeEstimator(EnsureAnyNodeContext(context));
-}
-
-LLMQContext& EnsureLLMQContext(const NodeContext& node)
-{
-    if (!node.llmq_ctx) {
-        throw JSONRPCError(RPC_INTERNAL_ERROR, "Node LLMQ context not found");
-    }
-    return *node.llmq_ctx;
-}
-
-LLMQContext& EnsureAnyLLMQContext(const CoreContext& context)
-{
-    return EnsureLLMQContext(EnsureAnyNodeContext(context));
-}
-
 /* Calculate the difficulty for a given block index.
  */
 double GetDifficulty(const CBlockIndex* blockindex)
@@ -825,6 +767,58 @@ static RPCHelpMan getmempoolentry()
     };
 }
 
+static RPCHelpMan getblockfrompeer()
+{
+    return RPCHelpMan{"getblockfrompeer",
+                "\nAttempt to fetch block from a given peer.\n"
+                "\nWe must have the header for this block, e.g. using submitheader.\n"
+                "\nReturns {} if a block-request was successfully scheduled\n",
+                {
+                    {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The block hash"},
+                    {"nodeid", RPCArg::Type::NUM, RPCArg::Optional::NO, "The node ID (see getpeerinfo for node IDs)"},
+                },
+                RPCResult{RPCResult::Type::OBJ, "", "",
+                {
+                    {RPCResult::Type::STR, "warnings", "any warnings"}
+                }},
+                RPCExamples{
+                    HelpExampleCli("getblockfrompeer", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\" 0")
+                + HelpExampleRpc("getblockfrompeer", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\" 0")
+                },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    const NodeContext& node = EnsureAnyNodeContext(request.context);
+    ChainstateManager& chainman = EnsureChainman(node);
+    PeerManager& peerman = EnsurePeerman(node);
+    CConnman& connman = EnsureConnman(node);
+
+    uint256 hash(ParseHashV(request.params[0], "hash"));
+
+    const NodeId nodeid = static_cast<NodeId>(request.params[1].get_int64());
+
+    // Check that the peer with nodeid exists
+    if (!connman.ForNode(nodeid, [](CNode* node) {return true;})) {
+        throw JSONRPCError(RPC_MISC_ERROR, strprintf("Peer nodeid %d does not exist", nodeid));
+    }
+
+    const CBlockIndex* const index = WITH_LOCK(cs_main, return chainman.m_blockman.LookupBlockIndex(hash););
+
+    if (!index) {
+        throw JSONRPCError(RPC_MISC_ERROR, "Block header missing");
+    }
+
+    UniValue result = UniValue::VOBJ;
+
+    if (index->nStatus & BLOCK_HAVE_DATA) {
+        result.pushKV("warnings", "Block already downloaded");
+    } else if (!peerman.FetchBlock(nodeid, hash, *index)) {
+        throw JSONRPCError(RPC_MISC_ERROR, "Failed to fetch block from peer");
+    }
+    return result;
+},
+    };
+}
+
 static RPCHelpMan getblockhashes()
 {
     return RPCHelpMan{"getblockhashes",
@@ -3058,6 +3052,7 @@ static const CRPCCommand commands[] =
     { "blockchain",         "getbestchainlock",       &getbestchainlock,       {} },
     { "blockchain",         "getblockcount",          &getblockcount,          {} },
     { "blockchain",         "getblock",               &getblock,               {"blockhash","verbosity|verbose"} },
+    { "blockchain",         "getblockfrompeer",       &getblockfrompeer,       {"blockhash", "nodeid"}},
     { "blockchain",         "getblockhashes",         &getblockhashes,         {"high","low"} },
     { "blockchain",         "getblockhash",           &getblockhash,           {"height"} },
     { "blockchain",         "getblockheader",         &getblockheader,         {"blockhash","verbose"} },
diff --git a/src/rpc/blockchain.h b/src/rpc/blockchain.h
index f67a853a2c..aebfb40000 100644
--- a/src/rpc/blockchain.h
+++ b/src/rpc/blockchain.h
@@ -6,7 +6,6 @@
 #define BITCOIN_RPC_BLOCKCHAIN_H
 
 #include <amount.h>
-#include <context.h>
 #include <core_io.h>
 #include <streams.h>
 #include <sync.h>
@@ -18,12 +17,9 @@ extern RecursiveMutex cs_main;
 
 class CBlock;
 class CBlockIndex;
-class CBlockPolicyEstimator;
 class CChainState;
 class CTxMemPool;
-class ChainstateManager;
 class UniValue;
-struct LLMQContext;
 struct NodeContext;
 namespace llmq {
 class CChainLocksHandler;
@@ -61,16 +57,6 @@ void CalculatePercentilesBySize(CAmount result[NUM_GETBLOCKSTATS_PERCENTILES], s
 void ScriptPubKeyToUniv(const CScript& scriptPubKey, UniValue& out, bool fIncludeHex);
 void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry, bool include_hex = true, const CTxUndo* txundo = nullptr, const CSpentIndexTxInfo* ptxSpentInfo = nullptr);
 
-NodeContext& EnsureAnyNodeContext(const CoreContext& context);
-CTxMemPool& EnsureMemPool(const NodeContext& node);
-CTxMemPool& EnsureAnyMemPool(const CoreContext& context);
-ChainstateManager& EnsureChainman(const NodeContext& node);
-ChainstateManager& EnsureAnyChainman(const CoreContext& context);
-CBlockPolicyEstimator& EnsureFeeEstimator(const NodeContext& node);
-CBlockPolicyEstimator& EnsureAnyFeeEstimator(const CoreContext& context);
-LLMQContext& EnsureLLMQContext(const NodeContext& node);
-LLMQContext& EnsureAnyLLMQContext(const CoreContext& context);
-
 /**
  * Helper to create UTXO snapshots given a chainstate and a file handle.
  * @return a UniValue map containing metadata about the snapshot.
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 4adea88520..754b024d2d 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -66,6 +66,7 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "getbalance", 2, "addlocked" },
     { "getbalance", 3, "include_watchonly" },
     { "getbalance", 4, "avoid_reuse" },
+    { "getblockfrompeer", 1, "nodeid" },
     { "getchaintips", 0, "count" },
     { "getchaintips", 1, "branchlen" },
     { "getblockhash", 0, "height" },
diff --git a/src/rpc/coinjoin.cpp b/src/rpc/coinjoin.cpp
index 0c03b56b34..e57531460d 100644
--- a/src/rpc/coinjoin.cpp
+++ b/src/rpc/coinjoin.cpp
@@ -7,8 +7,8 @@
 #include <coinjoin/context.h>
 #include <coinjoin/server.h>
 #include <rpc/blockchain.h>
-#include <rpc/net.h>
 #include <rpc/server.h>
+#include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <util/strencodings.h>
 
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
index 62b10a3762..edd3dbf63b 100644
--- a/src/rpc/evo.cpp
+++ b/src/rpc/evo.cpp
@@ -24,6 +24,7 @@
 #include <node/context.h>
 #include <rpc/blockchain.h>
 #include <rpc/server.h>
+#include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <util/moneystr.h>
 #include <util/translation.h>
diff --git a/src/rpc/governance.cpp b/src/rpc/governance.cpp
index 819859c003..7eba6e2c35 100644
--- a/src/rpc/governance.cpp
+++ b/src/rpc/governance.cpp
@@ -16,8 +16,8 @@
 #include <node/context.h>
 #include <net.h>
 #include <rpc/blockchain.h>
-#include <rpc/net.h>
 #include <rpc/server.h>
+#include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <governance/common.h>
 #include <util/strencodings.h>
diff --git a/src/rpc/masternode.cpp b/src/rpc/masternode.cpp
index eca27e7a2e..923cdc0993 100644
--- a/src/rpc/masternode.cpp
+++ b/src/rpc/masternode.cpp
@@ -15,8 +15,8 @@
 #include <net.h>
 #include <netbase.h>
 #include <rpc/blockchain.h>
-#include <rpc/net.h>
 #include <rpc/server.h>
+#include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <univalue.h>
 #include <util/strencodings.h>
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index 0bb051ad82..3ff88bfb0e 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -26,8 +26,8 @@
 #include <pow.h>
 #include <rpc/blockchain.h>
 #include <rpc/mining.h>
-#include <rpc/net.h>
 #include <rpc/server.h>
+#include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/script.h>
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 0e3d0a62b3..44a18f6341 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -19,8 +19,8 @@
 #include <net.h>
 #include <node/context.h>
 #include <rpc/blockchain.h>
-#include <rpc/net.h>
 #include <rpc/server.h>
+#include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <scheduler.h>
 #include <script/descriptor.h>
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index ffc3f7038f..c300fb5ee8 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -9,7 +9,6 @@
 #include <chainparams.h>
 #include <clientversion.h>
 #include <core_io.h>
-#include <net.h>
 #include <net_permissions.h>
 #include <net_processing.h>
 #include <net_types.h> // For banmap_t
@@ -18,12 +17,12 @@
 #include <policy/settings.h>
 #include <rpc/blockchain.h>
 #include <rpc/protocol.h>
+#include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <sync.h>
 #include <timedata.h>
 #include <util/strencodings.h>
 #include <util/string.h>
-#include <util/system.h>
 #include <util/translation.h>
 #include <validation.h>
 #include <version.h>
@@ -40,22 +39,6 @@ const std::vector<std::string> CONNECTION_TYPE_DOC{
         "feeler (short-lived automatic connection for testing addresses)"
 };
 
-CConnman& EnsureConnman(const NodeContext& node)
-{
-    if (!node.connman) {
-        throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
-    }
-    return *node.connman;
-}
-
-PeerManager& EnsurePeerman(const NodeContext& node)
-{
-    if (!node.peerman) {
-        throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
-    }
-    return *node.peerman;
-}
-
 static RPCHelpMan getconnectioncount()
 {
     return RPCHelpMan{"getconnectioncount",
diff --git a/src/rpc/net.h b/src/rpc/net.h
deleted file mode 100644
index 7a4d8440ba..0000000000
--- a/src/rpc/net.h
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) 2021 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_RPC_NET_H
-#define BITCOIN_RPC_NET_H
-
-class CConnman;
-class PeerManager;
-struct NodeContext;
-
-CConnman& EnsureConnman(const NodeContext& node);
-PeerManager& EnsurePeerman(const NodeContext& node);
-
-#endif // BITCOIN_RPC_NET_H
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index 876c313cad..a45cfa808f 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -7,8 +7,8 @@
 #include <index/txindex.h>
 #include <node/context.h>
 #include <rpc/blockchain.h>
-#include <rpc/net.h>
 #include <rpc/server.h>
+#include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <validation.h>
 
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 9f5d344cf7..02c5814538 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -28,6 +28,7 @@
 #include <rpc/blockchain.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/server.h>
+#include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <script/script.h>
 #include <script/sign.h>
diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp
index 81011c01c3..a47772a689 100644
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -9,6 +9,7 @@
 #include <chainparams.h>
 #include <node/context.h>
 #include <rpc/blockchain.h>
+#include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <shutdown.h>
 #include <sync.h>
diff --git a/src/rpc/server_util.cpp b/src/rpc/server_util.cpp
new file mode 100644
index 0000000000..fc79204c1a
--- /dev/null
+++ b/src/rpc/server_util.cpp
@@ -0,0 +1,93 @@
+// Copyright (c) 2021 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 <rpc/server_util.h>
+
+#include <net_processing.h>
+#include <node/context.h>
+#include <policy/fees.h>
+#include <rpc/protocol.h>
+#include <rpc/request.h>
+#include <txmempool.h>
+#include <util/system.h>
+#include <validation.h>
+
+#include <any>
+
+NodeContext& EnsureAnyNodeContext(const CoreContext& context)
+{
+    auto* const node_context = GetContext<NodeContext>(context);
+    if (!node_context) {
+        throw JSONRPCError(RPC_INTERNAL_ERROR, "Node context not found");
+    }
+    return *node_context;
+}
+
+CTxMemPool& EnsureMemPool(const NodeContext& node)
+{
+    if (!node.mempool) {
+        throw JSONRPCError(RPC_CLIENT_MEMPOOL_DISABLED, "Mempool disabled or instance not found");
+    }
+    return *node.mempool;
+}
+
+CTxMemPool& EnsureAnyMemPool(const CoreContext& context)
+{
+    return EnsureMemPool(EnsureAnyNodeContext(context));
+}
+
+ChainstateManager& EnsureChainman(const NodeContext& node)
+{
+    if (!node.chainman) {
+        throw JSONRPCError(RPC_INTERNAL_ERROR, "Node chainman not found");
+    }
+    return *node.chainman;
+}
+
+ChainstateManager& EnsureAnyChainman(const CoreContext& context)
+{
+    return EnsureChainman(EnsureAnyNodeContext(context));
+}
+
+CBlockPolicyEstimator& EnsureFeeEstimator(const NodeContext& node)
+{
+    if (!node.fee_estimator) {
+        throw JSONRPCError(RPC_INTERNAL_ERROR, "Fee estimation disabled");
+    }
+    return *node.fee_estimator;
+}
+
+CBlockPolicyEstimator& EnsureAnyFeeEstimator(const CoreContext& context)
+{
+    return EnsureFeeEstimator(EnsureAnyNodeContext(context));
+}
+
+LLMQContext& EnsureLLMQContext(const NodeContext& node)
+{
+    if (!node.llmq_ctx) {
+        throw JSONRPCError(RPC_INTERNAL_ERROR, "Node LLMQ context not found");
+    }
+    return *node.llmq_ctx;
+}
+
+LLMQContext& EnsureAnyLLMQContext(const CoreContext& context)
+{
+    return EnsureLLMQContext(EnsureAnyNodeContext(context));
+}
+
+CConnman& EnsureConnman(const NodeContext& node)
+{
+    if (!node.connman) {
+        throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
+    }
+    return *node.connman;
+}
+
+PeerManager& EnsurePeerman(const NodeContext& node)
+{
+    if (!node.peerman) {
+        throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
+    }
+    return *node.peerman;
+}
diff --git a/src/rpc/server_util.h b/src/rpc/server_util.h
new file mode 100644
index 0000000000..7960dc09c6
--- /dev/null
+++ b/src/rpc/server_util.h
@@ -0,0 +1,30 @@
+// Copyright (c) 2021 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_RPC_SERVER_UTIL_H
+#define BITCOIN_RPC_SERVER_UTIL_H
+
+#include <context.h>
+
+class CBlockPolicyEstimator;
+class CConnman;
+class ChainstateManager;
+class CTxMemPool;
+class PeerManager;
+struct NodeContext;
+struct LLMQContext;
+
+NodeContext& EnsureAnyNodeContext(const CoreContext& context);
+CTxMemPool& EnsureMemPool(const NodeContext& node);
+CTxMemPool& EnsureAnyMemPool(const CoreContext& context);
+ChainstateManager& EnsureChainman(const NodeContext& node);
+ChainstateManager& EnsureAnyChainman(const CoreContext& context);
+CBlockPolicyEstimator& EnsureFeeEstimator(const NodeContext& node);
+CBlockPolicyEstimator& EnsureAnyFeeEstimator(const CoreContext& context);
+LLMQContext& EnsureLLMQContext(const NodeContext& node);
+LLMQContext& EnsureAnyLLMQContext(const CoreContext& context);
+CConnman& EnsureConnman(const NodeContext& node);
+PeerManager& EnsurePeerman(const NodeContext& node);
+
+#endif // BITCOIN_RPC_SERVER_UTIL_H
diff --git a/src/validation.cpp b/src/validation.cpp
index ed4627e2a9..21b0e63c55 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -4170,6 +4170,7 @@ bool CChainState::AcceptBlock(const std::shared_ptr<const CBlock>& pblock, Block
     // This requires some new chain data structure to efficiently look up if a
     // block is in a chain leading to a candidate for best tip, despite not
     // being such a candidate itself.
+    // Note that this would break the getblockfrompeer RPC
 
     // TODO: deal better with return value and error conditions for duplicate
     // and unrequested blocks.
diff --git a/test/functional/rpc_getblockfrompeer.py b/test/functional/rpc_getblockfrompeer.py
new file mode 100755
index 0000000000..a5d02cbbf2
--- /dev/null
+++ b/test/functional/rpc_getblockfrompeer.py
@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# Copyright (c) 2020 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test the getblockfrompeer RPC."""
+
+from test_framework.authproxy import JSONRPCException
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_raises_rpc_error,
+)
+
+class GetBlockFromPeerTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 2
+
+    def setup_network(self):
+        self.setup_nodes()
+
+    def check_for_block(self, hash):
+        try:
+            self.nodes[0].getblock(hash)
+            return True
+        except JSONRPCException:
+            return False
+
+    def run_test(self):
+        self.log.info("Mine 4 blocks on Node 0")
+        self.nodes[0].generate(4)
+        assert_equal(self.nodes[0].getblockcount(), 204)
+
+        self.log.info("Mine competing 3 blocks on Node 1")
+        self.nodes[1].generate(3)
+        assert_equal(self.nodes[1].getblockcount(), 203)
+        short_tip = self.nodes[1].getbestblockhash()
+
+        self.log.info("Connect nodes to sync headers")
+        self.connect_nodes(0, 1)
+        self.sync_blocks()
+
+        self.log.info("Node 0 should only have the header for node 1's block 3")
+        for x in self.nodes[0].getchaintips():
+            if x['hash'] == short_tip:
+                assert_equal(x['status'], "headers-only")
+                break
+        else:
+            raise AssertionError("short tip not synced")
+        assert_raises_rpc_error(-1, "Block not found on disk", self.nodes[0].getblock, short_tip)
+
+        self.log.info("Fetch block from node 1")
+        peers = self.nodes[0].getpeerinfo()
+        assert_equal(len(peers), 1)
+        peer_0_peer_1_id = peers[0]["id"]
+
+        self.log.info("Arguments must be sensible")
+        assert_raises_rpc_error(-8, "hash must be of length 64 (not 4, for '1234')", self.nodes[0].getblockfrompeer, "1234", 0)
+
+        self.log.info("We must already have the header")
+        assert_raises_rpc_error(-1, "Block header missing", self.nodes[0].getblockfrompeer, "00" * 32, 0)
+
+        self.log.info("Non-existent peer generates error")
+        assert_raises_rpc_error(-1, f"Peer nodeid {peer_0_peer_1_id + 1} does not exist", self.nodes[0].getblockfrompeer, short_tip, peer_0_peer_1_id + 1)
+
+        self.log.info("Successful fetch")
+        result = self.nodes[0].getblockfrompeer(short_tip, peer_0_peer_1_id)
+        self.wait_until(lambda: self.check_for_block(short_tip), timeout=1)
+        assert(not "warnings" in result)
+
+        self.log.info("Don't fetch blocks we already have")
+        result = self.nodes[0].getblockfrompeer(short_tip, peer_0_peer_1_id)
+        assert("warnings" in result)
+        assert_equal(result["warnings"], "Block already downloaded")
+
+if __name__ == '__main__':
+    GetBlockFromPeerTest().main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 09f335c219..3af377ba30 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -234,6 +234,7 @@ BASE_SCRIPTS = [
     'wallet_txn_clone.py --mineblock',
     'feature_notifications.py',
     'rpc_getblockfilter.py',
+    'rpc_getblockfrompeer.py',
     'rpc_invalidateblock.py',
     'feature_txindex.py',
     'feature_utxo_set_hash.py',