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