1// Copyright (c) 2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <bitcoin-build-config.h> // IWYU pragma: keep
7
8#include <interfaces/mining.h>
9#include <rpc/register.h> // IWYU pragma: associated
10
11#include <addresstype.h>
12#include <arith_uint256.h>
13#include <chain.h>
14#include <chainparams.h>
15#include <chainparamsbase.h>
16#include <consensus/amount.h>
17#include <consensus/consensus.h>
18#include <consensus/merkle.h>
19#include <consensus/params.h>
20#include <consensus/validation.h>
21#include <core_io.h>
22#include <crypto/hex_base.h>
23#include <interfaces/types.h>
24#include <key_io.h>
25#include <net.h>
26#include <netbase.h>
27#include <node/blockstorage.h>
28#include <node/context.h>
29#include <node/miner.h>
30#include <node/mining_args.h>
31#include <node/mining_types.h>
32#include <node/warnings.h>
33#include <policy/feerate.h>
34#include <policy/policy.h>
35#include <pow.h>
36#include <primitives/block.h>
37#include <primitives/transaction.h>
38#include <rpc/blockchain.h>
39#include <rpc/mining.h>
40#include <rpc/protocol.h>
41#include <rpc/request.h>
42#include <rpc/server.h>
43#include <rpc/server_util.h>
44#include <rpc/util.h>
45#include <script/descriptor.h>
46#include <script/script.h>
47#include <script/signingprovider.h>
48#include <serialize.h>
49#include <streams.h>
50#include <sync.h>
51#include <tinyformat.h>
52#include <txmempool.h>
53#include <uint256.h>
54#include <univalue.h>
55#include <util/chaintype.h>
56#include <util/check.h>
57#include <util/signalinterrupt.h>
58#include <util/strencodings.h>
59#include <util/string.h>
60#include <util/time.h>
61#include <validation.h>
62#include <validationinterface.h>
63#include <versionbits.h>
64
65#include <algorithm>
66#include <cstddef>
67#include <cstdint>
68#include <functional>
69#include <limits>
70#include <map>
71#include <memory>
72#include <optional>
73#include <set>
74#include <span>
75#include <string>
76#include <string_view>
77#include <utility>
78#include <vector>
79
80using interfaces::BlockRef;
81using interfaces::BlockTemplate;
82using interfaces::Mining;
83using node::BlockAssembler;
84using node::GetMinimumTime;
85using node::NodeContext;
86using node::RegenerateCommitments;
87using node::UpdateTime;
88using util::ToString;
89
90/**
91 * Return average network hashes per second based on the last 'lookup' blocks,
92 * or from the last difficulty change if 'lookup' is -1.
93 * If 'height' is -1, compute the estimate from current chain tip.
94 * If 'height' is a valid block height, compute the estimate at the time when a given block was found.
95 */
96static UniValue GetNetworkHashPS(int lookup, int height, const CChain& active_chain) {
97    if (lookup < -1 || lookup == 0) {
98        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid nblocks. Must be a positive number or -1.");
99    }
100
101    if (height < -1 || height > active_chain.Height()) {
102        throw JSONRPCError(RPC_INVALID_PARAMETER, "Block does not exist at specified height");
103    }
104
105    const CBlockIndex* pb = active_chain.Tip();
106
107    if (height >= 0) {
108        pb = active_chain[height];
109    }
110
111    if (pb == nullptr || !pb->nHeight)
112        return 0;
113
114    // If lookup is -1, then use blocks since last difficulty change.
115    if (lookup == -1)
116        lookup = pb->nHeight % Params().GetConsensus().DifficultyAdjustmentInterval() + 1;
117
118    // If lookup is larger than chain, then set it to chain length.
119    if (lookup > pb->nHeight)
120        lookup = pb->nHeight;
121
122    const CBlockIndex* pb0 = pb;
123    int64_t minTime = pb0->GetBlockTime();
124    int64_t maxTime = minTime;
125    for (int i = 0; i < lookup; i++) {
126        pb0 = pb0->pprev;
127        int64_t time = pb0->GetBlockTime();
128        minTime = std::min(time, minTime);
129        maxTime = std::max(time, maxTime);
130    }
131
132    // In case there's a situation where minTime == maxTime, we don't want a divide by zero exception.
133    if (minTime == maxTime)
134        return 0;
135
136    arith_uint256 workDiff = pb->nChainWork - pb0->nChainWork;
137    int64_t timeDiff = maxTime - minTime;
138
139    return workDiff.getdouble() / timeDiff;
140}
141
142static RPCMethod getnetworkhashps()
143{
144    return RPCMethod{
145        "getnetworkhashps",
146        "Returns the estimated network hashes per second based on the last n blocks.\n"
147                "Pass in [blocks] to override # of blocks, -1 specifies since last difficulty change.\n"
148                "Pass in [height] to estimate the network speed at the time when a certain block was found.\n",
149                {
150                    {"nblocks", RPCArg::Type::NUM, RPCArg::Default{120}, "The number of previous blocks to calculate estimate from, or -1 for blocks since last difficulty change."},
151                    {"height", RPCArg::Type::NUM, RPCArg::Default{-1}, "To estimate at the time of the given height."},
152                },
153                RPCResult{
154                    RPCResult::Type::NUM, "", "Hashes per second estimated"},
155                RPCExamples{
156                    HelpExampleCli("getnetworkhashps", "")
157            + HelpExampleRpc("getnetworkhashps", "")
158                },
159        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
160{
161    ChainstateManager& chainman = EnsureAnyChainman(request.context);
162    LOCK(cs_main);
163    return GetNetworkHashPS(self.Arg<int>("nblocks"), self.Arg<int>("height"), chainman.ActiveChain());
164},
165    };
166}
167
168static bool GenerateBlock(ChainstateManager& chainman, CBlock&& block, uint64_t& max_tries, std::shared_ptr<const CBlock>& block_out, bool process_new_block)
169{
170    block_out.reset();
171    block.hashMerkleRoot = BlockMerkleRoot(block);
172
173    while (max_tries > 0 && block.nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(block.GetHash(), block.nBits, chainman.GetConsensus()) && !chainman.m_interrupt) {
174        ++block.nNonce;
175        --max_tries;
176    }
177    if (max_tries == 0 || chainman.m_interrupt) {
178        return false;
179    }
180    if (block.nNonce == std::numeric_limits<uint32_t>::max()) {
181        return true;
182    }
183
184    block_out = std::make_shared<const CBlock>(std::move(block));
185
186    if (!process_new_block) return true;
187
188    if (!chainman.ProcessNewBlock(block_out, /*force_processing=*/true, /*min_pow_checked=*/true, nullptr)) {
189        throw JSONRPCError(RPC_INTERNAL_ERROR, "ProcessNewBlock, block not accepted");
190    }
191
192    return true;
193}
194
195static UniValue generateBlocks(ChainstateManager& chainman, Mining& miner, const CScript& coinbase_output_script, int nGenerate, uint64_t nMaxTries)
196{
197    UniValue blockHashes(UniValue::VARR);
198    while (nGenerate > 0 && !chainman.m_interrupt) {
199        std::unique_ptr<BlockTemplate> block_template(miner.createNewBlock({ .coinbase_output_script = coinbase_output_script }, /*cooldown=*/false));
200        CHECK_NONFATAL(block_template);
201
202        std::shared_ptr<const CBlock> block_out;
203        if (!GenerateBlock(chainman, block_template->getBlock(), nMaxTries, block_out, /*process_new_block=*/true)) {
204            break;
205        }
206
207        if (block_out) {
208            --nGenerate;
209            blockHashes.push_back(block_out->GetHash().GetHex());
210        }
211    }
212    return blockHashes;
213}
214
215static bool getScriptFromDescriptor(std::string_view descriptor, CScript& script, std::string& error)
216{
217    FlatSigningProvider key_provider;
218    const auto descs = Parse(descriptor, key_provider, error, /* require_checksum = */ false);
219    if (descs.empty()) return false;
220    if (descs.size() > 1) {
221        throw JSONRPCError(RPC_INVALID_PARAMETER, "Multipath descriptor not accepted");
222    }
223    const auto& desc = descs.at(0);
224    if (desc->IsRange()) {
225        throw JSONRPCError(RPC_INVALID_PARAMETER, "Ranged descriptor not accepted. Maybe pass through deriveaddresses first?");
226    }
227
228    FlatSigningProvider provider;
229    std::vector<CScript> scripts;
230    if (!desc->Expand(0, key_provider, scripts, provider)) {
231        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Cannot derive script without private keys");
232    }
233
234    // Combo descriptors can have 2 or 4 scripts, so we can't just check scripts.size() == 1
235    CHECK_NONFATAL(scripts.size() > 0 && scripts.size() <= 4);
236
237    if (scripts.size() == 1) {
238        script = scripts.at(0);
239    } else if (scripts.size() == 4) {
240        // For uncompressed keys, take the 3rd script, since it is p2wpkh
241        script = scripts.at(2);
242    } else {
243        // Else take the 2nd script, since it is p2pkh
244        script = scripts.at(1);
245    }
246
247    return true;
248}
249
250static RPCMethod generatetodescriptor()