Branch data Line data Source code
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 <rpc/register.h> // IWYU pragma: associated
7 : :
8 : : #include <addresstype.h>
9 : : #include <crypto/hex_base.h>
10 : : #include <key.h>
11 : : #include <key_io.h>
12 : : #include <outputtype.h>
13 : : #include <pubkey.h>
14 : : #include <rpc/protocol.h>
15 : : #include <rpc/request.h>
16 : : #include <rpc/server.h>
17 : : #include <rpc/util.h>
18 : : #include <script/descriptor.h>
19 : : #include <script/script.h>
20 : : #include <script/signingprovider.h>
21 : : #include <tinyformat.h>
22 : : #include <univalue.h>
23 : : #include <util/check.h>
24 : :
25 : : #include <cstddef>
26 : : #include <cstdint>
27 : : #include <map>
28 : : #include <memory>
29 : : #include <optional>
30 : : #include <span>
31 : : #include <string>
32 : : #include <string_view>
33 : : #include <tuple>
34 : : #include <utility>
35 : : #include <variant>
36 : : #include <vector>
37 : :
38 : 2682 : static RPCMethod validateaddress()
39 : : {
40 : 2682 : return RPCMethod{
41 : 2682 : "validateaddress",
42 [ + - ]: 5364 : "Return information about the given bitcoin address.\n",
43 : : {
44 [ + - + - ]: 5364 : {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to validate"},
45 : : },
46 [ + - ]: 5364 : RPCResult{
47 [ + - + - ]: 5364 : RPCResult::Type::OBJ, "", "",
48 : : {
49 [ + - + - ]: 5364 : {RPCResult::Type::BOOL, "isvalid", "If the address is valid or not"},
50 [ + - + - ]: 5364 : {RPCResult::Type::STR, "address", /*optional=*/true, "The bitcoin address validated"},
51 [ + - + - ]: 5364 : {RPCResult::Type::STR_HEX, "scriptPubKey", /*optional=*/true, "The hex-encoded output script generated by the address"},
52 [ + - + - ]: 5364 : {RPCResult::Type::BOOL, "isscript", /*optional=*/true, "If the key is a script"},
53 [ + - + - ]: 5364 : {RPCResult::Type::BOOL, "iswitness", /*optional=*/true, "If the address is a witness address"},
54 [ + - + - ]: 5364 : {RPCResult::Type::NUM, "witness_version", /*optional=*/true, "The version number of the witness program"},
55 [ + - + - ]: 5364 : {RPCResult::Type::STR_HEX, "witness_program", /*optional=*/true, "The hex value of the witness program"},
56 [ + - + - ]: 5364 : {RPCResult::Type::STR, "error", /*optional=*/true, "Error message, if any"},
57 [ + - + - ]: 5364 : {RPCResult::Type::ARR, "error_locations", /*optional=*/true, "Indices of likely error locations in address, if known (e.g. Bech32 errors)",
58 : : {
59 [ + - + - ]: 5364 : {RPCResult::Type::NUM, "index", "index of a potential error"},
60 : : }},
61 : : }
62 [ + - + - : 61686 : },
+ - + + +
+ - - -
- ]
63 : 2682 : RPCExamples{
64 [ + - + - : 8046 : HelpExampleCli("validateaddress", "\"" + EXAMPLE_ADDRESS[0] + "\"") +
+ - ]
65 [ + - + - : 10728 : HelpExampleRpc("validateaddress", "\"" + EXAMPLE_ADDRESS[0] + "\"")
+ - + - ]
66 [ + - ]: 2682 : },
67 : 2682 : [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
68 : : {
69 [ + - ]: 148 : std::string error_msg;
70 : 148 : std::vector<int> error_locations;
71 [ + - + - : 148 : CTxDestination dest = DecodeDestination(request.params[0].get_str(), error_msg, &error_locations);
+ - ]
72 [ + - ]: 148 : const bool isValid = IsValidDestination(dest);
73 [ + - ]: 148 : CHECK_NONFATAL(isValid == error_msg.empty());
74 : :
75 : 148 : UniValue ret(UniValue::VOBJ);
76 [ + - + - : 296 : ret.pushKV("isvalid", isValid);
+ - ]
77 [ + + ]: 148 : if (isValid) {
78 [ + - ]: 102 : std::string currentAddress = EncodeDestination(dest);
79 [ + - + - : 204 : ret.pushKV("address", currentAddress);
+ - ]
80 : :
81 [ + - ]: 102 : CScript scriptPubKey = GetScriptForDestination(dest);
82 [ + + + - : 306 : ret.pushKV("scriptPubKey", HexStr(scriptPubKey));
+ - + - +
- ]
83 : :
84 [ + - ]: 102 : UniValue detail = DescribeAddress(dest);
85 [ + - ]: 102 : ret.pushKVs(std::move(detail));
86 : 102 : } else {
87 : 46 : UniValue error_indices(UniValue::VARR);
88 [ + - + - : 58 : for (int i : error_locations) error_indices.push_back(i);
+ + ]
89 [ + - + - ]: 92 : ret.pushKV("error_locations", std::move(error_indices));
90 [ + - + - : 92 : ret.pushKV("error", error_msg);
+ - ]
91 : 46 : }
92 : :
93 : 148 : return ret;
94 : 148 : },
95 [ + - + - : 13410 : };
+ + - - ]
96 [ + - + - : 59004 : }
+ - + - +
- + - + -
+ - + - +
- + - -
- ]
97 : :
98 : 2617 : static RPCMethod createmultisig()
99 : : {
100 : 2617 : return RPCMethod{
101 : 2617 : "createmultisig",
102 [ + - ]: 5234 : "Creates a multi-signature address with n signatures of m keys required.\n"
103 : : "It returns a json object with the address and redeemScript.\n",
104 : : {
105 [ + - + - ]: 5234 : {"nrequired", RPCArg::Type::NUM, RPCArg::Optional::NO, "The number of required signatures out of the m keys."},
106 [ + - + - ]: 5234 : {"keys", RPCArg::Type::ARR, RPCArg::Optional::NO, "The hex-encoded public keys.",
107 : : {
108 [ + - + - ]: 5234 : {"key", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The hex-encoded public key"},
109 : : }},
110 [ + - + - : 7851 : {"address_type", RPCArg::Type::STR, RPCArg::Default{"legacy"}, "The address type to use. Options are \"legacy\", \"p2sh-segwit\", and \"bech32\"."},
+ - ]
111 : : },
112 [ + - ]: 5234 : RPCResult{
113 [ + - + - ]: 5234 : RPCResult::Type::OBJ, "", "",
114 : : {
115 [ + - + - ]: 5234 : {RPCResult::Type::STR, "address", "The value of the new multisig address."},
116 [ + - + - ]: 5234 : {RPCResult::Type::STR_HEX, "redeemScript", "The string value of the hex-encoded redemption script."},
117 [ + - + - ]: 5234 : {RPCResult::Type::STR, "descriptor", "The descriptor for this multisig"},
118 [ + - + - ]: 5234 : {RPCResult::Type::ARR, "warnings", /*optional=*/true, "Any warnings resulting from the creation of this multisig",
119 : : {
120 [ + - + - ]: 5234 : {RPCResult::Type::STR, "", ""},
121 : : }},
122 : : }
123 [ + - + - : 34021 : },
+ - + + +
+ - - -
- ]
124 : 2617 : RPCExamples{
125 : : "\nCreate a multisig address from 2 public keys\n"
126 [ + - + - : 5234 : + HelpExampleCli("createmultisig", "2 \"[\\\"03789ed0bb717d88f7d321a368d905e7430207ebbd82bd342cf11ae157a7ace5fd\\\",\\\"03dbc6764b8884a92e871274b87583e6d5c2a58819473e17e107ef3f6aa5a61626\\\"]\"") +
+ - + - ]
127 : 2617 : "\nAs a JSON-RPC call\n"
128 [ + - + - : 10468 : + HelpExampleRpc("createmultisig", "2, [\"03789ed0bb717d88f7d321a368d905e7430207ebbd82bd342cf11ae157a7ace5fd\",\"03dbc6764b8884a92e871274b87583e6d5c2a58819473e17e107ef3f6aa5a61626\"]")
+ - + - ]
129 [ + - ]: 2617 : },
130 : 2617 : [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
131 : : {
132 : 85 : int required = request.params[0].getInt<int>();
133 : :
134 : : // Get the public keys
135 : 85 : const UniValue& keys = request.params[1].get_array();
136 : 85 : std::vector<CPubKey> pubkeys;
137 [ - + + - ]: 85 : pubkeys.reserve(keys.size());
138 [ - + + + ]: 648 : for (unsigned int i = 0; i < keys.size(); ++i) {
139 [ + - + - : 1126 : pubkeys.push_back(HexToPubKey(keys[i].get_str()));
+ - ]
140 : : }
141 : :
142 : : // Get the output type
143 [ + - ]: 85 : auto address_type{self.Arg<std::string_view>("address_type")};
144 [ + - ]: 85 : auto output_type{ParseOutputType(address_type)};
145 [ + + ]: 85 : if (!output_type) {
146 [ + - + - ]: 2 : throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, tfm::format("Unknown address type '%s'", address_type));
147 [ + + ]: 84 : } else if (output_type.value() == OutputType::BECH32M) {
148 [ + - + - ]: 2 : throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "createmultisig cannot create bech32m multisig addresses");
149 : : }
150 : :
151 : 83 : FlatSigningProvider keystore;
152 : 83 : CScript inner;
153 [ + + ]: 83 : const CTxDestination dest = AddAndGetMultisigDestination(required, pubkeys, output_type.value(), keystore, inner);
154 : :
155 : : // Make the descriptor
156 [ + - + - ]: 80 : std::unique_ptr<Descriptor> descriptor = InferDescriptor(GetScriptForDestination(dest), keystore);
157 : :
158 : 80 : UniValue result(UniValue::VOBJ);
159 [ + - + - : 160 : result.pushKV("address", EncodeDestination(dest));
+ - + - ]
160 [ + - + - : 240 : result.pushKV("redeemScript", HexStr(inner));
+ - + - +
- ]
161 [ + - + - : 160 : result.pushKV("descriptor", descriptor->ToString());
+ - + - ]
162 : :
163 : 80 : UniValue warnings(UniValue::VARR);
164 [ + - ]: 80 : if (descriptor->GetOutputType() != output_type.value()) {
165 : : // Only warns if the user has explicitly chosen an address type we cannot generate
166 [ + - + - ]: 12 : warnings.push_back("Unable to make chosen address type, please ensure no uncompressed public keys are present.");
167 : : }
168 [ + - ]: 80 : PushWarnings(warnings, result);
169 : :
170 : 160 : return result;
171 : 83 : },
172 [ + - + - : 26170 : };
+ - + + +
+ - - -
- ]
173 [ + - + - : 47106 : }
+ - + - +
- + - + -
+ - + - -
- - - ]
174 : :
175 : 2788 : static RPCMethod getdescriptorinfo()
176 : : {
177 : 2788 : const std::string EXAMPLE_DESCRIPTOR = "wpkh([d34db33f/84h/0h/0h]0279be667ef9dcbbac55a06295Ce870b07029Bfcdb2dce28d959f2815b16f81798)";
178 : :
179 : 2788 : return RPCMethod{
180 [ + - ]: 5576 : "getdescriptorinfo",
181 [ + - ]: 5576 : "Analyses a descriptor.\n",
182 : : {
183 [ + - + - ]: 5576 : {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor."},
184 : : },
185 [ + - ]: 5576 : RPCResult{
186 [ + - + - ]: 5576 : RPCResult::Type::OBJ, "", "",
187 : : {
188 [ + - + - ]: 5576 : {RPCResult::Type::STR, "descriptor", "The descriptor, without private keys. For a multipath descriptor, only the first will be returned."},
189 [ + - + - ]: 2788 : {RPCResult::Type::ARR, "multipath_expansion", /*optional=*/true, "All descriptors produced by expanding multipath derivation elements. Only if the provided descriptor specifies multipath derivation elements.",
190 : : {
191 [ + - + - ]: 5576 : {RPCResult::Type::STR, "", ""},
192 : : }},
193 [ + - + - ]: 5576 : {RPCResult::Type::STR, "checksum", "The checksum for the input descriptor"},
194 [ + - + - ]: 5576 : {RPCResult::Type::BOOL, "isrange", "Whether the descriptor is ranged"},
195 [ + - + - ]: 5576 : {RPCResult::Type::BOOL, "issolvable", "Whether the descriptor is solvable"},
196 [ + - + - ]: 5576 : {RPCResult::Type::BOOL, "hasprivatekeys", "Whether the input descriptor contained at least one private key"},
197 : : }
198 [ + - + - : 47396 : },
+ - + + +
+ - - -
- ]
199 : 2788 : RPCExamples{
200 : 2788 : "Analyse a descriptor\n" +
201 [ + - + - : 11152 : HelpExampleCli("getdescriptorinfo", "\"" + EXAMPLE_DESCRIPTOR + "\"") +
+ - + - ]
202 [ + - + - : 11152 : HelpExampleRpc("getdescriptorinfo", "\"" + EXAMPLE_DESCRIPTOR + "\"")
+ - + - ]
203 [ + - ]: 2788 : },
204 : 2788 : [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
205 : : {
206 : 254 : FlatSigningProvider provider;
207 [ + - ]: 254 : std::string error;
208 [ + - + - ]: 254 : auto descs = Parse(self.Arg<std::string_view>("descriptor"), provider, error);
209 [ + + ]: 254 : if (descs.empty()) {
210 [ + - ]: 6 : throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
211 : : }
212 : :
213 : 248 : UniValue result(UniValue::VOBJ);
214 [ + - + - : 496 : result.pushKV("descriptor", descs.at(0)->ToString());
+ - + - +
- ]
215 : :
216 [ - + + + ]: 248 : if (descs.size() > 1) {
217 : 5 : UniValue multipath_descs(UniValue::VARR);
218 [ + + ]: 15 : for (const auto& d : descs) {
219 [ + - + - : 10 : multipath_descs.push_back(d->ToString());
+ - ]
220 : : }
221 [ + - + - : 10 : result.pushKV("multipath_expansion", multipath_descs);
+ - ]
222 : 5 : }
223 : :
224 [ + - + - : 496 : result.pushKV("checksum", GetDescriptorChecksum(request.params[0].get_str()));
+ - + - +
- + - ]
225 [ + - + - : 496 : result.pushKV("isrange", descs.at(0)->IsRange());
+ - + - +
- ]
226 [ + - + - : 496 : result.pushKV("issolvable", descs.at(0)->IsSolvable());
+ - + - +
- ]
227 [ + - + - : 496 : result.pushKV("hasprivatekeys", provider.keys.size() > 0);
+ - ]
228 : 248 : return result;
229 : 260 : },
230 [ + - + - : 11152 : };
+ + - - ]
231 [ + - + - : 47396 : }
+ - + - +
- + - + -
+ - - - ]
232 : :
233 : 197 : static UniValue DeriveAddresses(const Descriptor* desc, int64_t range_begin, int64_t range_end, FlatSigningProvider& key_provider)
234 : : {
235 : 197 : UniValue addresses(UniValue::VARR);
236 : :
237 [ + + ]: 406 : for (int64_t i = range_begin; i <= range_end; ++i) {
238 : 215 : FlatSigningProvider provider;
239 : 215 : std::vector<CScript> scripts;
240 [ + - + + ]: 215 : if (!desc->Expand(i, key_provider, scripts, provider)) {
241 [ + - + - ]: 4 : throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Cannot derive script without private keys");
242 : : }
243 : :
244 [ + + ]: 428 : for (const CScript& script : scripts) {
245 : 219 : CTxDestination dest;
246 [ + - + + ]: 219 : if (!ExtractDestination(script, dest)) {
247 : : // ExtractDestination no longer returns true for P2PK since it doesn't have a corresponding address
248 : : // However combo will output P2PK and should just ignore that script
249 [ - + + + ]: 6 : if (scripts.size() > 1 && std::get_if<PubKeyDestination>(&dest)) {
250 : 2 : continue;
251 : : }
252 [ + - + - ]: 8 : throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Descriptor does not have a corresponding address");
253 : : }
254 : :
255 [ + - + - : 213 : addresses.push_back(EncodeDestination(dest));
+ - ]
256 : 219 : }
257 : 221 : }
258 : :
259 : : // This should not be possible, but an assert seems overkill:
260 [ - + - + ]: 191 : if (addresses.empty()) {
261 [ # # # # ]: 0 : throw JSONRPCError(RPC_MISC_ERROR, "Unexpected empty result");
262 : : }
263 : :
264 : 191 : return addresses;
265 : 6 : }
266 : :
267 : 2745 : static RPCMethod deriveaddresses()
268 : : {
269 : 2745 : const std::string EXAMPLE_DESCRIPTOR = "wpkh([d34db33f/84h/0h/0h]xpub6DJ2dNUysrn5Vt36jH2KLBT2i1auw1tTSSomg8PhqNiUtx8QX2SvC9nrHu81fT41fvDUnhMjEzQgXnQjKEu3oaqMSzhSrHMxyyoEAmUHQbY/0/*)#cjjspncu";
270 : :
271 : 2745 : return RPCMethod{
272 [ + - ]: 5490 : "deriveaddresses",
273 [ + - ]: 5490 : "Derives one or more addresses corresponding to an output descriptor.\n"
274 : : "Examples of output descriptors are:\n"
275 : : " pkh(<pubkey>) P2PKH outputs for the given pubkey\n"
276 : : " wpkh(<pubkey>) Native segwit P2PKH outputs for the given pubkey\n"
277 : : " sh(multi(<n>,<pubkey>,<pubkey>,...)) P2SH-multisig outputs for the given threshold and pubkeys\n"
278 : : " raw(<hex script>) Outputs whose output script equals the specified hex-encoded bytes\n"
279 : : " tr(<pubkey>,multi_a(<n>,<pubkey>,<pubkey>,...)) P2TR-multisig outputs for the given threshold and pubkeys\n"
280 : : "\nIn the above, <pubkey> either refers to a fixed public key in hexadecimal notation, or to an xpub/xprv optionally followed by one\n"
281 : : "or more path elements separated by \"/\", where \"h\" represents a hardened child key.\n"
282 : : "For more information on output descriptors, see the documentation in the doc/descriptors.md file.\n",
283 : : {
284 [ + - + - ]: 5490 : {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor."},
285 [ + - + - ]: 5490 : {"range", RPCArg::Type::RANGE, RPCArg::Optional::OMITTED, "If a ranged descriptor is used, this specifies the end or the range (in [begin,end] notation) to derive."},
286 : : },
287 : : {
288 [ + - ]: 2745 : RPCResult{"for single derivation descriptors",
289 [ + - + - ]: 5490 : RPCResult::Type::ARR, "", "",
290 : : {
291 [ + - + - ]: 5490 : {RPCResult::Type::STR, "address", "the derived addresses"},
292 : : }
293 [ + - + + : 10980 : },
- - ]
294 [ + - ]: 5490 : RPCResult{"for multipath descriptors",
295 [ + - + - ]: 5490 : RPCResult::Type::ARR, "", "The derived addresses for each of the multipath expansions of the descriptor, in multipath specifier order",
296 : : {
297 : : {
298 [ + - + - ]: 5490 : RPCResult::Type::ARR, "", "The derived addresses for a multipath descriptor expansion",
299 : : {
300 [ + - + - ]: 5490 : {RPCResult::Type::STR, "address", "the derived address"},
301 : : },
302 : : },
303 : : },
304 [ + - + - : 19215 : },
+ + + + -
- - - ]
305 : : },
306 : 2745 : RPCExamples{
307 : 2745 : "First three native segwit receive addresses\n" +
308 [ + - + - : 10980 : HelpExampleCli("deriveaddresses", "\"" + EXAMPLE_DESCRIPTOR + "\" \"[0,2]\"") +
+ - + - ]
309 [ + - + - : 8235 : HelpExampleRpc("deriveaddresses", "\"" + EXAMPLE_DESCRIPTOR + "\", \"[0,2]\"")
+ - ]
310 [ + - ]: 2745 : },
311 : 2745 : [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
312 : : {
313 : 213 : auto desc_str{self.Arg<std::string_view>("descriptor")};
314 : :
315 : 213 : int64_t range_begin = 0;
316 : 213 : int64_t range_end = 0;
317 : :
318 : 213 : const UniValue* range = self.MaybeArg<UniValue>("range");
319 [ + + ]: 213 : if (range) {
320 : 80 : std::tie(range_begin, range_end) = ParseDescriptorRange(*range);
321 : : }
322 : :
323 : 205 : FlatSigningProvider key_provider;
324 [ + - ]: 205 : std::string error;
325 [ + - ]: 205 : auto descs = Parse(desc_str, key_provider, error, /* require_checksum = */ true);
326 [ + + ]: 205 : if (descs.empty()) {
327 [ + - ]: 4 : throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
328 : : }
329 [ + - ]: 201 : auto& desc = descs.at(0);
330 [ + - + + : 201 : if (!desc->IsRange() && range) {
+ + ]
331 [ + - + - ]: 4 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Range should not be specified for an un-ranged descriptor");
332 : : }
333 : :
334 [ + - + + : 199 : if (desc->IsRange() && !range) {
+ + ]
335 [ + - + - ]: 8 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Range must be specified for a ranged descriptor");
336 : : }
337 : :
338 [ + + ]: 195 : UniValue addresses = DeriveAddresses(desc.get(), range_begin, range_end, key_provider);
339 : :
340 [ - + + + ]: 189 : if (descs.size() == 1) {
341 : 187 : return addresses;
342 : : }
343 : :
344 : 2 : UniValue ret(UniValue::VARR);
345 [ + - + - ]: 2 : ret.push_back(addresses);
346 [ - + + + ]: 4 : for (size_t i = 1; i < descs.size(); ++i) {
347 [ + - + - : 2 : ret.push_back(DeriveAddresses(descs.at(i).get(), range_begin, range_end, key_provider));
+ - ]
348 : : }
349 : 2 : return ret;
350 : 221 : },
351 [ + - + - : 27450 : };
+ - + - +
+ + + - -
- - ]
352 [ + - + - : 41175 : }
+ - + - +
- + - + -
- - - - ]
353 : :
354 : 1395 : void RegisterOutputScriptRPCCommands(CRPCTable& t)
355 : : {
356 : 1395 : static const CRPCCommand commands[]{
357 [ + - ]: 2518 : {"util", &validateaddress},
358 [ + - ]: 2518 : {"util", &createmultisig},
359 [ + - ]: 2518 : {"util", &deriveaddresses},
360 [ + - ]: 2518 : {"util", &getdescriptorinfo},
361 [ + + + - : 6431 : };
+ - + - +
- + - -
- ]
362 [ + + ]: 6975 : for (const auto& c : commands) {
363 : 5580 : t.appendCommand(c.name, &c);
364 : : }
365 : 1395 : }
|
