Validating addresses and deriving descriptor outputs

251                }
252                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Descriptor does not have a corresponding address");
253            }
254
255            addresses.push_back(EncodeDestination(dest));
256        }
257    }
258
259    // This should not be possible, but an assert seems overkill:
260    if (addresses.empty()) {
261        throw JSONRPCError(RPC_MISC_ERROR, "Unexpected empty result");
262    }
263
264    return addresses;
265}
266
267static RPCMethod deriveaddresses()
268{
269    const std::string EXAMPLE_DESCRIPTOR = "wpkh([d34db33f/84h/0h/0h]xpub6DJ2dNUysrn5Vt36jH2KLBT2i1auw1tTSSomg8PhqNiUtx8QX2SvC9nrHu81fT41fvDUnhMjEzQgXnQjKEu3oaqMSzhSrHMxyyoEAmUHQbY/0/*)#cjjspncu";
270
271    return RPCMethod{
272        "deriveaddresses",
273        "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            {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor."},
285            {"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            RPCResult{"for single derivation descriptors",
289                RPCResult::Type::ARR, "", "",
290                {
291                    {RPCResult::Type::STR, "address", "the derived addresses"},
292                }
293            },
294            RPCResult{"for multipath descriptors",
295                RPCResult::Type::ARR, "", "The derived addresses for each of the multipath expansions of the descriptor, in multipath specifier order",
296                {
297                    {
298                        RPCResult::Type::ARR, "", "The derived addresses for a multipath descriptor expansion",
299                        {
300                            {RPCResult::Type::STR, "address", "the derived address"},
301                        },
302                    },
303                },
304            },
305        },
306        RPCExamples{
307            "First three native segwit receive addresses\n" +
308            HelpExampleCli("deriveaddresses", "\"" + EXAMPLE_DESCRIPTOR + "\" \"[0,2]\"") +
309            HelpExampleRpc("deriveaddresses", "\"" + EXAMPLE_DESCRIPTOR + "\", \"[0,2]\"")
310        },
311        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
312        {
313            auto desc_str{self.Arg<std::string_view>("descriptor")};
314
315            int64_t range_begin = 0;
316            int64_t range_end = 0;
317
318            const UniValue* range = self.MaybeArg<UniValue>("range");
319            if (range) {
320                std::tie(range_begin, range_end) = ParseDescriptorRange(*range);
321            }
322
323            FlatSigningProvider key_provider;
324            std::string error;
325            auto descs = Parse(desc_str, key_provider, error, /* require_checksum = */ true);
326            if (descs.empty()) {
327                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
328            }
329            auto& desc = descs.at(0);
330            if (!desc->IsRange() && range) {
331                throw JSONRPCError(RPC_INVALID_PARAMETER, "Range should not be specified for an un-ranged descriptor");
332            }
333
334            if (desc->IsRange() && !range) {
335                throw JSONRPCError(RPC_INVALID_PARAMETER, "Range must be specified for a ranged descriptor");
336            }
337
338            UniValue addresses = DeriveAddresses(desc.get(), range_begin, range_end, key_provider);
339
340            if (descs.size() == 1) {
341                return addresses;
342            }
343
344            UniValue ret(UniValue::VARR);
345            ret.push_back(addresses);
346            for (size_t i = 1; i < descs.size(); ++i) {
347                ret.push_back(DeriveAddresses(descs.at(i).get(), range_begin, range_end, key_provider));
348            }
349            return ret;
350        },
351    };
352}
353
354void RegisterOutputScriptRPCCommands(CRPCTable& t)
355{
356    static const CRPCCommand commands[]{
357        {"util", &validateaddress},
358        {"util", &createmultisig},
359        {"util", &deriveaddresses},
360        {"util", &getdescriptorinfo},
361    };
362    for (const auto& c : commands) {
363        t.appendCommand(c.name, &c);
364    }
365}
366