Branch data Line data Source code
1 : : // Copyright (c) 2009-2022 The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #if defined(HAVE_CONFIG_H)
6 : : #include <config/bitcoin-config.h>
7 : : #endif
8 : :
9 : : #include <arith_uint256.h>
10 : : #include <chain.h>
11 : : #include <chainparams.h>
12 : : #include <chainparamsbase.h>
13 : : #include <clientversion.h>
14 : : #include <common/args.h>
15 : : #include <common/system.h>
16 : : #include <compat/compat.h>
17 : : #include <core_io.h>
18 : : #include <streams.h>
19 : : #include <util/exception.h>
20 : : #include <util/strencodings.h>
21 : : #include <util/translation.h>
22 : : #include <version.h>
23 : :
24 : : #include <atomic>
25 : : #include <cstdio>
26 : : #include <functional>
27 : : #include <memory>
28 : : #include <thread>
29 : :
30 : : static const int CONTINUE_EXECUTION=-1;
31 : :
32 : 0 : const std::function<std::string(const char*)> G_TRANSLATION_FUN = nullptr;
33 : :
34 : 0 : static void SetupBitcoinUtilArgs(ArgsManager &argsman)
35 : : {
36 : 0 : SetupHelpOptions(argsman);
37 : :
38 : 0 : argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
39 : :
40 : 0 : argsman.AddCommand("grind", "Perform proof of work on hex header string");
41 : :
42 : 0 : SetupChainParamsBaseOptions(argsman);
43 : 0 : }
44 : :
45 : : // This function returns either one of EXIT_ codes when it's expected to stop the process or
46 : : // CONTINUE_EXECUTION when it's expected to continue further.
47 : 0 : static int AppInitUtil(ArgsManager& args, int argc, char* argv[])
48 : : {
49 : 0 : SetupBitcoinUtilArgs(args);
50 : 0 : std::string error;
51 : 0 : if (!args.ParseParameters(argc, argv, error)) {
52 : 0 : tfm::format(std::cerr, "Error parsing command line arguments: %s\n", error);
53 : 0 : return EXIT_FAILURE;
54 : : }
55 : :
56 : 0 : if (HelpRequested(args) || args.IsArgSet("-version")) {
57 : : // First part of help message is specific to this utility
58 : 0 : std::string strUsage = PACKAGE_NAME " bitcoin-util utility version " + FormatFullVersion() + "\n";
59 : :
60 : 0 : if (args.IsArgSet("-version")) {
61 : 0 : strUsage += FormatParagraph(LicenseInfo());
62 : 0 : } else {
63 : 0 : strUsage += "\n"
64 : : "Usage: bitcoin-util [options] [commands] Do stuff\n";
65 : 0 : strUsage += "\n" + args.GetHelpMessage();
66 : : }
67 : :
68 : 0 : tfm::format(std::cout, "%s", strUsage);
69 : :
70 : 0 : if (argc < 2) {
71 : 0 : tfm::format(std::cerr, "Error: too few parameters\n");
72 : 0 : return EXIT_FAILURE;
73 : : }
74 : 0 : return EXIT_SUCCESS;
75 : 0 : }
76 : :
77 : : // Check for chain settings (Params() calls are only valid after this clause)
78 : : try {
79 : 0 : SelectParams(args.GetChainType());
80 : 0 : } catch (const std::exception& e) {
81 : 0 : tfm::format(std::cerr, "Error: %s\n", e.what());
82 : 0 : return EXIT_FAILURE;
83 : 0 : }
84 : :
85 : 0 : return CONTINUE_EXECUTION;
86 : 0 : }
87 : :
88 : 0 : static void grind_task(uint32_t nBits, CBlockHeader header, uint32_t offset, uint32_t step, std::atomic<bool>& found, uint32_t& proposed_nonce)
89 : : {
90 : 0 : arith_uint256 target;
91 : : bool neg, over;
92 : 0 : target.SetCompact(nBits, &neg, &over);
93 : 0 : if (target == 0 || neg || over) return;
94 : 0 : header.nNonce = offset;
95 : :
96 : 0 : uint32_t finish = std::numeric_limits<uint32_t>::max() - step;
97 : 0 : finish = finish - (finish % step) + offset;
98 : :
99 : 0 : while (!found && header.nNonce < finish) {
100 : 0 : const uint32_t next = (finish - header.nNonce < 5000*step) ? finish : header.nNonce + 5000*step;
101 : 0 : do {
102 : 0 : if (UintToArith256(header.GetHash()) <= target) {
103 : 0 : if (!found.exchange(true)) {
104 : 0 : proposed_nonce = header.nNonce;
105 : 0 : }
106 : 0 : return;
107 : : }
108 : 0 : header.nNonce += step;
109 : 0 : } while(header.nNonce != next);
110 : : }
111 : 0 : }
112 : :
113 : 0 : static int Grind(const std::vector<std::string>& args, std::string& strPrint)
114 : : {
115 : 0 : if (args.size() != 1) {
116 : 0 : strPrint = "Must specify block header to grind";
117 : 0 : return EXIT_FAILURE;
118 : : }
119 : :
120 : 0 : CBlockHeader header;
121 : 0 : if (!DecodeHexBlockHeader(header, args[0])) {
122 : 0 : strPrint = "Could not decode block header";
123 : 0 : return EXIT_FAILURE;
124 : : }
125 : :
126 : 0 : uint32_t nBits = header.nBits;
127 : 0 : std::atomic<bool> found{false};
128 : 0 : uint32_t proposed_nonce{};
129 : :
130 : 0 : std::vector<std::thread> threads;
131 : 0 : int n_tasks = std::max(1u, std::thread::hardware_concurrency());
132 : 0 : threads.reserve(n_tasks);
133 : 0 : for (int i = 0; i < n_tasks; ++i) {
134 : 0 : threads.emplace_back(grind_task, nBits, header, i, n_tasks, std::ref(found), std::ref(proposed_nonce));
135 : 0 : }
136 : 0 : for (auto& t : threads) {
137 : 0 : t.join();
138 : : }
139 : 0 : if (found) {
140 : 0 : header.nNonce = proposed_nonce;
141 : 0 : } else {
142 : 0 : strPrint = "Could not satisfy difficulty target";
143 : 0 : return EXIT_FAILURE;
144 : : }
145 : :
146 : 0 : DataStream ss{};
147 : 0 : ss << header;
148 : 0 : strPrint = HexStr(ss);
149 : 0 : return EXIT_SUCCESS;
150 : 0 : }
151 : :
152 : 0 : MAIN_FUNCTION
153 : : {
154 : 0 : ArgsManager& args = gArgs;
155 : 0 : SetupEnvironment();
156 : :
157 : : try {
158 : 0 : int ret = AppInitUtil(args, argc, argv);
159 : 0 : if (ret != CONTINUE_EXECUTION) {
160 : 0 : return ret;
161 : : }
162 : 0 : } catch (const std::exception& e) {
163 : 0 : PrintExceptionContinue(&e, "AppInitUtil()");
164 : 0 : return EXIT_FAILURE;
165 : 0 : } catch (...) {
166 : 0 : PrintExceptionContinue(nullptr, "AppInitUtil()");
167 : 0 : return EXIT_FAILURE;
168 : 0 : }
169 : :
170 : 0 : const auto cmd = args.GetCommand();
171 : 0 : if (!cmd) {
172 : 0 : tfm::format(std::cerr, "Error: must specify a command\n");
173 : 0 : return EXIT_FAILURE;
174 : : }
175 : :
176 : 0 : int ret = EXIT_FAILURE;
177 : 0 : std::string strPrint;
178 : : try {
179 : 0 : if (cmd->command == "grind") {
180 : 0 : ret = Grind(cmd->args, strPrint);
181 : 0 : } else {
182 : 0 : assert(false); // unknown command should be caught earlier
183 : : }
184 : 0 : } catch (const std::exception& e) {
185 : 0 : strPrint = std::string("error: ") + e.what();
186 : 0 : } catch (...) {
187 : 0 : strPrint = "unknown error";
188 : 0 : }
189 : :
190 : 0 : if (strPrint != "") {
191 : 0 : tfm::format(ret == 0 ? std::cout : std::cerr, "%s\n", strPrint);
192 : 0 : }
193 : :
194 : 0 : return ret;
195 : 0 : }
|
