1// Copyright (c) 2009-present 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#include <chain.h>
6#include <clientversion.h>
7#include <core_io.h>
8#include <hash.h>
9#include <interfaces/chain.h>
10#include <key_io.h>
11#include <merkleblock.h>
12#include <node/types.h>
13#include <rpc/util.h>
14#include <script/descriptor.h>
15#include <script/script.h>
16#include <script/solver.h>
17#include <sync.h>
18#include <uint256.h>
19#include <util/bip32.h>
20#include <util/check.h>
21#include <util/fs.h>
22#include <util/time.h>
23#include <util/translation.h>
24#include <wallet/export.h>
25#include <wallet/rpc/util.h>
26#include <wallet/wallet.h>
27
28#include <cstdint>
29#include <fstream>
30#include <tuple>
31#include <string>
32
33#include <univalue.h>
34
35
36
37using interfaces::FoundBlock;
38
39namespace wallet {
40RPCMethod importprunedfunds()
41{
42    return RPCMethod{
43        "importprunedfunds",
44        "Imports funds without rescan. Corresponding address or script must previously be included in wallet. Aimed towards pruned wallets. The end-user is responsible to import additional transactions that subsequently spend the imported outputs or rescan after the point in the blockchain the transaction is included.\n",
45                {
46                    {"rawtransaction", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "A raw transaction in hex funding an already-existing address in wallet"},
47                    {"txoutproof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex output from gettxoutproof that contains the transaction"},
48                },
49                RPCResult{RPCResult::Type::NONE, "", ""},
50                RPCExamples{""},
51        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
52{
53    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
54    if (!pwallet) return UniValue::VNULL;
55
56    CMutableTransaction tx;
57    if (!DecodeHexTx(tx, request.params[0].get_str())) {
58        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed. Make sure the tx has at least one input.");
59    }
60
61    CMerkleBlock merkleBlock;
62    SpanReader{ParseHexV(request.params[1], "proof")} >> merkleBlock;
63
64    //Search partial merkle tree in proof for our transaction and index in valid block
65    std::vector<Txid> vMatch;
66    std::vector<unsigned int> vIndex;
67    if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) != merkleBlock.header.hashMerkleRoot) {
68        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Something wrong with merkleblock");
69    }
70
71    LOCK(pwallet->cs_wallet);
72    int height;
73    if (!pwallet->chain().findAncestorByHash(pwallet->GetLastBlockHash(), merkleBlock.header.GetHash(), FoundBlock().height(height))) {
74        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found in chain");
75    }
76
77    std::vector<Txid>::const_iterator it;
78    if ((it = std::find(vMatch.begin(), vMatch.end(), tx.GetHash())) == vMatch.end()) {
79        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction given doesn't exist in proof");
80    }
81
82    unsigned int txnIndex = vIndex[it - vMatch.begin()];
83
84    CTransactionRef tx_ref = MakeTransactionRef(tx);
85    if (pwallet->IsMine(*tx_ref)) {
86        pwallet->AddToWallet(std::move(tx_ref), TxStateConfirmed{merkleBlock.header.GetHash(), height, static_cast<int>(txnIndex)});
87        return UniValue::VNULL;
88    }
89
90    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No addresses in wallet correspond to included transaction");
91},
92    };
93}
94
95RPCMethod removeprunedfunds()
96{
97    return RPCMethod{
98        "removeprunedfunds",
99        "(DEPRECATED) This feature will be removed in the next major release. Start bitcoind with the `-deprecatedrpc=removeprunedfunds` option in order to use this.\n"
100        "Deletes the specified transaction from the wallet. Meant for use with pruned wallets and as a companion to importprunedfunds. This will affect wallet balances.\n",
101                {
102                    {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex-encoded id of the transaction you are deleting"},
103                },
104                RPCResult{RPCResult::Type::NONE, "", ""},
105                RPCExamples{
106                    HelpExampleCli("removeprunedfunds", "\"a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\"") +
107            "\nAs a JSON-RPC call\n"
108            + HelpExampleRpc("removeprunedfunds", "\"a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\"")
109                },
110        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
111{
112    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
113    if (!pwallet) return UniValue::VNULL;
114
115    if (!pwallet->chain().rpcEnableDeprecated("removeprunedfunds")) {
116        throw JSONRPCError(RPC_METHOD_DEPRECATED, "DEPRECATION WARNING: This feature will be removed in the next major release. Start bitcoind with the `-deprecatedrpc=removeprunedfunds` option in order to use this.");
117    }
118
119    LOCK(pwallet->cs_wallet);
120
121    Txid hash{Txid::FromUint256(ParseHashV(request.params[0], "txid"))};
122    std::vector<Txid> vHash;
123    vHash.push_back(hash);
124    if (auto res = pwallet->RemoveTxs(vHash); !res) {
125        throw JSONRPCError(RPC_WALLET_ERROR, util::ErrorString(res).original);
126    }
127
128    return UniValue::VNULL;
129},
130    };
131}
132
133static int64_t GetImportTimestamp(const UniValue& data, int64_t now)
134{
135    if (data.exists("timestamp")) {
136        const UniValue& timestamp = data["timestamp"];
137        if (timestamp.isNum()) {
138            return timestamp.getInt<int64_t>();
139        } else if (timestamp.isStr() && timestamp.get_str() == "now") {
140            return now;
141        }
142        throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Expected number or \"now\" timestamp value for key. got type %s", uvTypeName(timestamp.type())));
143    }
144    throw JSONRPCError(RPC_TYPE_ERROR, "Missing required timestamp field for key");
145}
146
147static UniValue ProcessDescriptorImport(CWallet& wallet, const UniValue& data, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
148{
149    UniValue warnings(UniValue::VARR);
150    UniValue result(UniValue::VOBJ);
151
152    try {
153        if (!data.exists("desc")) {
154            throw JSONRPCError(RPC_INVALID_PARAMETER, "Descriptor not found.");
155        }
156
157        const std::string& descriptor = data["desc"].get_str();
158        const bool active = data.exists("active") ? data["active"].get_bool() : false;
159        const std::string label{LabelFromValue(data["label"])};
160
161        // Parse descriptor string
162        FlatSigningProvider keys;
163        std::string error;
164        auto parsed_descs = Parse(descriptor, keys, error, /* require_checksum = */ true);
165        if (parsed_descs.empty()) {
166            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
167        }
168        std::optional<bool> internal;
169        if (data.exists("internal")) {
170            if (parsed_descs.size() > 1) {
171                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Cannot have multipath descriptor while also specifying \'internal\'");
172            }
173            internal = data["internal"].get_bool();
174        }
175
176        // Range check
177        std::optional<bool> is_ranged;
178        int64_t range_start = 0, range_end = 1, next_index = 0;
179        if (!parsed_descs.at(0)->IsRange() && data.exists("range")) {
180            throw JSONRPCError(RPC_INVALID_PARAMETER, "Range should not be specified for an un-ranged descriptor");
181        } else if (parsed_descs.at(0)->IsRange()) {
182            if (data.exists("range")) {
183                auto range = ParseDescriptorRange(data["range"]);
184                range_start = range.first;
185                range_end = range.second + 1; // Specified range end is inclusive, but we need range end as exclusive
186            } else {
187                warnings.push_back("Range not given, using default keypool range");
188                range_start = 0;
189                range_end = wallet.m_keypool_size;
190            }
191            next_index = range_start;
192            is_ranged = true;
193
194            if (data.exists("next_index")) {
195                next_index = data["next_index"].getInt<int64_t>();
196                // bound checks
197                if (next_index < range_start || next_index >= range_end) {
198                    throw JSONRPCError(RPC_INVALID_PARAMETER, "next_index is out of range");
199                }
200            }
201        }
202
203        // Active descriptors must be ranged
204        if (active && !parsed_descs.at(0)->IsRange()) {
205            throw JSONRPCError(RPC_INVALID_PARAMETER, "Active descriptors must be ranged");
206        }
207
208        // Multipath descriptors should not have a label
209        if (parsed_descs.size() > 1 && data.exists("label")) {
210            throw JSONRPCError(RPC_INVALID_PARAMETER, "Multipath descriptors should not have a label");
211        }
212
213        // Ranged descriptors should not have a label
214        if (is_ranged.has_value() && is_ranged.value() && data.exists("label")) {
215            throw JSONRPCError(RPC_INVALID_PARAMETER, "Ranged descriptors should not have a label");
216        }
217
218        bool desc_internal = internal.has_value() && internal.value();
219        // Internal addresses should not have a label either
220        if (desc_internal && data.exists("label")) {
221            throw JSONRPCError(RPC_INVALID_PARAMETER, "Internal addresses should not have a label");
222        }
223
224        // Combo descriptor check
225        if (active && !parsed_descs.at(0)->IsSingleType()) {
226            throw JSONRPCError(RPC_WALLET_ERROR, "Combo descriptors cannot be set to active");
227        }
228
229        // If the wallet disabled private keys, abort if private keys exist
230        if (wallet.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && !keys.keys.empty()) {
231            throw JSONRPCError(RPC_WALLET_ERROR, "Cannot import private keys to a wallet with private keys disabled");
232        }
233
234        for (size_t j = 0; j < parsed_descs.size(); ++j) {
235            auto parsed_desc = std::move(parsed_descs[j]);
236            if (parsed_descs.size() == 2) {
237                desc_internal = j == 1;
238            } else if (parsed_descs.size() > 2) {
239                CHECK_NONFATAL(!desc_internal);
240            }
241            // Expand to check whether the descriptor can be derived at the first index.
242            FlatSigningProvider expand_keys;
243            std::vector<CScript> scripts;
244            if (!parsed_desc->Expand(0, keys, scripts, expand_keys)) {
245                throw JSONRPCError(RPC_WALLET_ERROR, "Cannot expand descriptor. Probably because of hardened derivations without private keys provided");
246            }
247
248            for (const auto& w : parsed_desc->Warnings()) {
249               warnings.push_back(w);
250            }