LCOV - code coverage report
Current view: top level - src/wallet/rpc - coins.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 17 483 3.5 %
Date: 2023-11-06 23:13:05 Functions: 0 26 0.0 %
Branches: 21 1860 1.1 %

           Branch data     Line data    Source code
       1                 :            : // Copyright (c) 2011-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                 :            : #include <core_io.h>
       6                 :            : #include <hash.h>
       7                 :            : #include <key_io.h>
       8                 :            : #include <rpc/util.h>
       9                 :            : #include <script/script.h>
      10                 :            : #include <util/moneystr.h>
      11                 :            : #include <wallet/coincontrol.h>
      12                 :            : #include <wallet/receive.h>
      13                 :            : #include <wallet/rpc/util.h>
      14                 :            : #include <wallet/spend.h>
      15                 :            : #include <wallet/wallet.h>
      16                 :            : 
      17         [ +  - ]:          2 : #include <univalue.h>
      18         [ +  - ]:          2 : 
      19                 :            : 
      20                 :            : namespace wallet {
      21                 :          0 : static CAmount GetReceived(const CWallet& wallet, const UniValue& params, bool by_label) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
      22                 :            : {
      23                 :          0 :     std::vector<CTxDestination> addresses;
      24         [ #  # ]:          0 :     if (by_label) {
      25                 :            :         // Get the set of addresses assigned to label
      26 [ #  # ][ #  # ]:          0 :         addresses = wallet.ListAddrBookAddresses(CWallet::AddrBookFilter{LabelFromValue(params[0])});
                 [ #  # ]
      27 [ #  # ][ #  # ]:          2 :         if (addresses.empty()) throw JSONRPCError(RPC_WALLET_ERROR, "Label not found in wallet");
         [ #  # ][ #  # ]
      28 [ +  - ][ +  - ]:          6 :     } else {
         [ +  - ][ -  + ]
                 [ #  # ]
      29 [ +  - ][ +  - ]:          2 :         // Get the address
                 [ +  - ]
      30 [ +  - ][ +  - ]:          2 :         CTxDestination dest = DecodeDestination(params[0].get_str());
         [ +  - ][ #  # ]
         [ #  # ][ #  # ]
      31 [ #  # ][ #  # ]:          0 :         if (!IsValidDestination(dest)) {
      32 [ #  # ][ #  # ]:          0 :             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
                 [ #  # ]
      33                 :            :         }
      34         [ #  # ]:          0 :         addresses.emplace_back(dest);
      35                 :          0 :     }
      36                 :            : 
      37                 :            :     // Filter by own scripts only
      38                 :          0 :     std::set<CScript> output_scripts;
      39         [ #  # ]:          0 :     for (const auto& address : addresses) {
      40         [ #  # ]:          0 :         auto output_script{GetScriptForDestination(address)};
      41 [ #  # ][ #  # ]:          0 :         if (wallet.IsMine(output_script)) {
      42         [ #  # ]:          0 :             output_scripts.insert(output_script);
      43                 :          0 :         }
      44                 :          0 :     }
      45                 :            : 
      46         [ #  # ]:          0 :     if (output_scripts.empty()) {
      47 [ #  # ][ #  # ]:          0 :         throw JSONRPCError(RPC_WALLET_ERROR, "Address not found in wallet");
                 [ #  # ]
      48                 :            :     }
      49                 :            : 
      50                 :            :     // Minimum confirmations
      51                 :          0 :     int min_depth = 1;
      52 [ #  # ][ #  # ]:          0 :     if (!params[1].isNull())
                 [ #  # ]
      53 [ #  # ][ #  # ]:          0 :         min_depth = params[1].getInt<int>();
                 [ #  # ]
      54                 :            : 
      55 [ #  # ][ #  # ]:          0 :     const bool include_immature_coinbase{params[2].isNull() ? false : params[2].get_bool()};
         [ #  # ][ #  # ]
                 [ #  # ]
      56                 :            : 
      57                 :            :     // Tally
      58                 :          0 :     CAmount amount = 0;
      59         [ #  # ]:          0 :     for (const std::pair<const uint256, CWalletTx>& wtx_pair : wallet.mapWallet) {
      60                 :          0 :         const CWalletTx& wtx = wtx_pair.second;
      61         [ #  # ]:          0 :         int depth{wallet.GetTxDepthInMainChain(wtx)};
      62         [ #  # ]:          0 :         if (depth < min_depth
      63                 :            :             // Coinbase with less than 1 confirmation is no longer in the main chain
      64 [ #  # ][ #  # ]:          0 :             || (wtx.IsCoinBase() && (depth < 1))
                 [ #  # ]
      65 [ #  # ][ #  # ]:          0 :             || (wallet.IsTxImmatureCoinBase(wtx) && !include_immature_coinbase))
                 [ #  # ]
      66                 :            :         {
      67                 :          0 :             continue;
      68                 :            :         }
      69                 :            : 
      70         [ #  # ]:          0 :         for (const CTxOut& txout : wtx.tx->vout) {
      71         [ #  # ]:          0 :             if (output_scripts.count(txout.scriptPubKey) > 0) {
      72                 :          0 :                 amount += txout.nValue;
      73                 :          0 :             }
      74                 :            :         }
      75                 :            :     }
      76                 :            : 
      77                 :          0 :     return amount;
      78                 :          0 : }
      79                 :            : 
      80                 :            : 
      81                 :          0 : RPCHelpMan getreceivedbyaddress()
      82                 :            : {
      83 [ #  # ][ #  # ]:          0 :     return RPCHelpMan{"getreceivedbyaddress",
                 [ #  # ]
      84         [ #  # ]:          0 :                 "\nReturns the total amount received by the given address in transactions with at least minconf confirmations.\n",
      85         [ #  # ]:          0 :                 {
      86 [ #  # ][ #  # ]:          0 :                     {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address for transactions."},
                 [ #  # ]
      87 [ #  # ][ #  # ]:          0 :                     {"minconf", RPCArg::Type::NUM, RPCArg::Default{1}, "Only include transactions confirmed at least this many times."},
         [ #  # ][ #  # ]
      88 [ #  # ][ #  # ]:          0 :                     {"include_immature_coinbase", RPCArg::Type::BOOL, RPCArg::Default{false}, "Include immature coinbase transactions."},
         [ #  # ][ #  # ]
      89                 :            :                 },
      90 [ #  # ][ #  # ]:          0 :                 RPCResult{
      91 [ #  # ][ #  # ]:          2 :                     RPCResult::Type::STR_AMOUNT, "amount", "The total amount in " + CURRENCY_UNIT + " received at this address."
                 [ #  # ]
      92                 :            :                 },
      93         [ #  # ]:          0 :                 RPCExamples{
      94                 :            :             "\nThe amount from transactions with at least 1 confirmation\n"
      95 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("getreceivedbyaddress", "\"" + EXAMPLE_ADDRESS[0] + "\"") +
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
      96                 :            :             "\nThe amount including unconfirmed transactions, zero confirmations\n"
      97 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("getreceivedbyaddress", "\"" + EXAMPLE_ADDRESS[0] + "\" 0") +
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
      98                 :            :             "\nThe amount with at least 6 confirmations\n"
      99 [ #  # ][ #  # ]:          2 :             + HelpExampleCli("getreceivedbyaddress", "\"" + EXAMPLE_ADDRESS[0] + "\" 6") +
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     100                 :            :             "\nThe amount with at least 6 confirmations including immature coinbase outputs\n"
     101 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("getreceivedbyaddress", "\"" + EXAMPLE_ADDRESS[0] + "\" 6 true") +
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     102                 :            :             "\nAs a JSON-RPC call\n"
     103 [ #  # ][ #  # ]:          0 :             + HelpExampleRpc("getreceivedbyaddress", "\"" + EXAMPLE_ADDRESS[0] + "\", 6")
         [ #  # ][ #  # ]
                 [ #  # ]
     104                 :            :                 },
     105                 :          0 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     106                 :            : {
     107                 :          0 :     const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
     108 [ #  # ][ #  # ]:          0 :     if (!pwallet) return UniValue::VNULL;
     109                 :            : 
     110                 :            :     // Make sure the results are valid at least up to the most recent block
     111                 :            :     // the user could have gotten from another RPC command prior to now
     112         [ #  # ]:          0 :     pwallet->BlockUntilSyncedToCurrentChain();
     113                 :            : 
     114 [ #  # ][ #  # ]:          0 :     LOCK(pwallet->cs_wallet);
     115                 :            : 
     116 [ #  # ][ #  # ]:          0 :     return ValueFromAmount(GetReceived(*pwallet, request.params, /*by_label=*/false));
     117                 :          0 : },
     118                 :            :     };
     119                 :          0 : }
     120                 :            : 
     121                 :            : 
     122                 :          0 : RPCHelpMan getreceivedbylabel()
     123                 :            : {
     124 [ #  # ][ #  # ]:          0 :     return RPCHelpMan{"getreceivedbylabel",
                 [ #  # ]
     125         [ #  # ]:          0 :                 "\nReturns the total amount received by addresses with <label> in transactions with at least [minconf] confirmations.\n",
     126         [ #  # ]:          0 :                 {
     127 [ #  # ][ #  # ]:          0 :                     {"label", RPCArg::Type::STR, RPCArg::Optional::NO, "The selected label, may be the default label using \"\"."},
                 [ #  # ]
     128 [ #  # ][ #  # ]:          0 :                     {"minconf", RPCArg::Type::NUM, RPCArg::Default{1}, "Only include transactions confirmed at least this many times."},
         [ #  # ][ #  # ]
     129 [ #  # ][ #  # ]:          0 :                     {"include_immature_coinbase", RPCArg::Type::BOOL, RPCArg::Default{false}, "Include immature coinbase transactions."},
         [ #  # ][ #  # ]
     130                 :            :                 },
     131 [ #  # ][ #  # ]:          0 :                 RPCResult{
     132 [ #  # ][ #  # ]:          0 :                     RPCResult::Type::STR_AMOUNT, "amount", "The total amount in " + CURRENCY_UNIT + " received for this label."
                 [ #  # ]
     133                 :            :                 },
     134         [ #  # ]:          0 :                 RPCExamples{
     135                 :            :             "\nAmount received by the default label with at least 1 confirmation\n"
     136 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("getreceivedbylabel", "\"\"") +
         [ #  # ][ #  # ]
                 [ #  # ]
     137                 :            :             "\nAmount received at the tabby label including unconfirmed amounts with zero confirmations\n"
     138 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("getreceivedbylabel", "\"tabby\" 0") +
         [ #  # ][ #  # ]
                 [ #  # ]
     139                 :            :             "\nThe amount with at least 6 confirmations\n"
     140 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("getreceivedbylabel", "\"tabby\" 6") +
         [ #  # ][ #  # ]
                 [ #  # ]
     141                 :            :             "\nThe amount with at least 6 confirmations including immature coinbase outputs\n"
     142 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("getreceivedbylabel", "\"tabby\" 6 true") +
         [ #  # ][ #  # ]
                 [ #  # ]
     143                 :            :             "\nAs a JSON-RPC call\n"
     144 [ #  # ][ #  # ]:          0 :             + HelpExampleRpc("getreceivedbylabel", "\"tabby\", 6, true")
         [ #  # ][ #  # ]
     145                 :            :                 },
     146                 :          0 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     147                 :            : {
     148                 :          0 :     const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
     149 [ #  # ][ #  # ]:          0 :     if (!pwallet) return UniValue::VNULL;
     150                 :            : 
     151                 :          0 :     // Make sure the results are valid at least up to the most recent block
     152                 :            :     // the user could have gotten from another RPC command prior to now
     153         [ #  # ]:          0 :     pwallet->BlockUntilSyncedToCurrentChain();
     154                 :            : 
     155         [ #  # ]:          0 :     LOCK(pwallet->cs_wallet);
     156                 :            : 
     157 [ #  # ][ #  # ]:          0 :     return ValueFromAmount(GetReceived(*pwallet, request.params, /*by_label=*/true));
     158                 :          0 : },
     159                 :            :     };
     160                 :          0 : }
     161                 :            : 
     162                 :            : 
     163         [ +  - ]:          2 : RPCHelpMan getbalance()
     164         [ +  - ]:          2 : {
     165 [ +  - ][ #  # ]:          2 :     return RPCHelpMan{"getbalance",
         [ #  # ][ #  # ]
     166 [ +  - ][ #  # ]:          2 :                 "\nReturns the total available balance.\n"
     167         [ +  - ]:          2 :                 "The available balance is what the wallet considers currently spendable, and is\n"
     168         [ +  - ]:          2 :                 "thus affected by options which limit spendability such as -spendzeroconfchange.\n",
     169 [ +  - ][ #  # ]:          2 :                 {
     170 [ +  - ][ #  # ]:          2 :                     {"dummy", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Remains for backward compatibility. Must be excluded or set to \"*\"."},
         [ #  # ][ #  # ]
     171 [ #  # ][ #  # ]:          0 :                     {"minconf", RPCArg::Type::NUM, RPCArg::Default{0}, "Only include transactions confirmed at least this many times."},
         [ #  # ][ #  # ]
     172 [ #  # ][ #  # ]:          0 :                     {"include_watchonly", RPCArg::Type::BOOL, RPCArg::DefaultHint{"true for watch-only wallets, otherwise false"}, "Also include balance in watch-only addresses (see 'importaddress')"},
         [ #  # ][ #  # ]
     173 [ #  # ][ #  # ]:          0 :                     {"avoid_reuse", RPCArg::Type::BOOL, RPCArg::Default{true}, "(only available if avoid_reuse wallet flag is set) Do not include balance in dirty outputs; addresses are considered dirty if they have previously been used in a transaction."},
         [ #  # ][ #  # ]
     174                 :            :                 },
     175 [ #  # ][ #  # ]:          0 :                 RPCResult{
     176 [ #  # ][ #  # ]:          0 :                     RPCResult::Type::STR_AMOUNT, "amount", "The total amount in " + CURRENCY_UNIT + " received for this wallet."
                 [ #  # ]
     177                 :            :                 },
     178         [ #  # ]:          0 :                 RPCExamples{
     179                 :            :             "\nThe total amount in the wallet with 0 or more confirmations\n"
     180 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("getbalance", "") +
         [ #  # ][ #  # ]
                 [ #  # ]
     181                 :            :             "\nThe total amount in the wallet with at least 6 confirmations\n"
     182 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("getbalance", "\"*\" 6") +
         [ #  # ][ #  # ]
                 [ #  # ]
     183                 :            :             "\nAs a JSON-RPC call\n"
     184 [ #  # ][ #  # ]:          0 :             + HelpExampleRpc("getbalance", "\"*\", 6")
         [ #  # ][ #  # ]
     185                 :            :                 },
     186                 :          0 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     187                 :            : {
     188                 :          0 :     const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
     189 [ #  # ][ #  # ]:          0 :     if (!pwallet) return UniValue::VNULL;
     190                 :            : 
     191                 :            :     // Make sure the results are valid at least up to the most recent block
     192                 :            :     // the user could have gotten from another RPC command prior to now
     193         [ #  # ]:          0 :     pwallet->BlockUntilSyncedToCurrentChain();
     194                 :            : 
     195         [ #  # ]:          0 :     LOCK(pwallet->cs_wallet);
     196                 :            : 
     197         [ #  # ]:          0 :     const auto dummy_value{self.MaybeArg<std::string>(0)};
     198 [ #  # ][ #  # ]:          0 :     if (dummy_value && *dummy_value != "*") {
                 [ #  # ]
     199 [ #  # ][ #  # ]:          0 :         throw JSONRPCError(RPC_METHOD_DEPRECATED, "dummy first argument must be excluded or set to \"*\".");
         [ #  # ][ #  # ]
     200                 :            :     }
     201                 :            : 
     202                 :          0 :     int min_depth = 0;
     203 [ #  # ][ #  # ]:          0 :     if (!request.params[1].isNull()) {
     204 [ #  # ][ #  # ]:          0 :         min_depth = request.params[1].getInt<int>();
     205                 :          0 :     }
     206                 :            : 
     207 [ #  # ][ #  # ]:          0 :     bool include_watchonly = ParseIncludeWatchonly(request.params[2], *pwallet);
     208                 :            : 
     209 [ #  # ][ #  # ]:          0 :     bool avoid_reuse = GetAvoidReuseFlag(*pwallet, request.params[3]);
     210                 :            : 
     211         [ #  # ]:          0 :     const auto bal = GetBalance(*pwallet, min_depth, avoid_reuse);
     212                 :            : 
     213 [ #  # ][ #  # ]:          0 :     return ValueFromAmount(bal.m_mine_trusted + (include_watchonly ? bal.m_watchonly_trusted : 0));
     214                 :          0 : },
     215                 :            :     };
     216                 :          0 : }
     217                 :            : 
     218                 :          0 : RPCHelpMan getunconfirmedbalance()
     219                 :            : {
     220 [ #  # ][ #  # ]:          0 :     return RPCHelpMan{"getunconfirmedbalance",
     221         [ #  # ]:          0 :                 "DEPRECATED\nIdentical to getbalances().mine.untrusted_pending\n",
     222                 :          0 :                 {},
     223 [ #  # ][ #  # ]:          0 :                 RPCResult{RPCResult::Type::NUM, "", "The balance"},
         [ #  # ][ #  # ]
     224 [ #  # ][ #  # ]:          0 :                 RPCExamples{""},
     225                 :          0 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     226                 :            : {
     227                 :          0 :     const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
     228 [ #  # ][ #  # ]:          0 :     if (!pwallet) return UniValue::VNULL;
     229                 :            : 
     230                 :            :     // Make sure the results are valid at least up to the most recent block
     231                 :            :     // the user could have gotten from another RPC command prior to now
     232         [ #  # ]:          0 :     pwallet->BlockUntilSyncedToCurrentChain();
     233                 :            : 
     234         [ #  # ]:          0 :     LOCK(pwallet->cs_wallet);
     235                 :            : 
     236 [ #  # ][ #  # ]:          0 :     return ValueFromAmount(GetBalance(*pwallet).m_mine_untrusted_pending);
     237                 :          0 : },
     238                 :            :     };
     239                 :          0 : }
     240                 :            : 
     241                 :          0 : RPCHelpMan lockunspent()
     242                 :            : {
     243 [ #  # ][ #  # ]:          0 :     return RPCHelpMan{"lockunspent",
         [ #  # ][ #  # ]
                 [ #  # ]
     244         [ #  # ]:          0 :                 "\nUpdates list of temporarily unspendable outputs.\n"
     245                 :            :                 "Temporarily lock (unlock=false) or unlock (unlock=true) specified transaction outputs.\n"
     246                 :            :                 "If no transaction outputs are specified when unlocking then all current locked transaction outputs are unlocked.\n"
     247                 :            :                 "A locked transaction output will not be chosen by automatic coin selection, when spending bitcoins.\n"
     248                 :            :                 "Manually selected coins are automatically unlocked.\n"
     249                 :            :                 "Locks are stored in memory only, unless persistent=true, in which case they will be written to the\n"
     250                 :            :                 "wallet database and loaded on node start. Unwritten (persistent=false) locks are always cleared\n"
     251                 :            :                 "(by virtue of process exit) when a node stops or fails. Unlocking will clear both persistent and not.\n"
     252                 :            :                 "Also see the listunspent call\n",
     253         [ #  # ]:          0 :                 {
     254 [ #  # ][ #  # ]:          0 :                     {"unlock", RPCArg::Type::BOOL, RPCArg::Optional::NO, "Whether to unlock (true) or lock (false) the specified transactions"},
                 [ #  # ]
     255 [ #  # ][ #  # ]:          0 :                     {"transactions", RPCArg::Type::ARR, RPCArg::Default{UniValue::VARR}, "The transaction outputs and within each, the txid (string) vout (numeric).",
         [ #  # ][ #  # ]
     256         [ #  # ]:          0 :                         {
     257 [ #  # ][ #  # ]:          0 :                             {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
                 [ #  # ]
     258         [ #  # ]:          0 :                                 {
     259 [ #  # ][ #  # ]:          0 :                                     {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
                 [ #  # ]
     260 [ #  # ][ #  # ]:          0 :                                     {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
                 [ #  # ]
     261                 :            :                                 },
     262                 :            :                             },
     263                 :            :                         },
     264         [ +  - ]:          2 :                     },
     265 [ #  # ][ #  # ]:          0 :                     {"persistent", RPCArg::Type::BOOL, RPCArg::Default{false}, "Whether to write/erase this lock in the wallet database, or keep the change in memory only. Ignored for unlocking."},
         [ #  # ][ #  # ]
     266                 :            :                 },
     267 [ #  # ][ #  # ]:          0 :                 RPCResult{
     268 [ #  # ][ #  # ]:          0 :                     RPCResult::Type::BOOL, "", "Whether the command was successful or not"
     269                 :            :                 },
     270         [ #  # ]:          0 :                 RPCExamples{
     271                 :            :             "\nList the unspent transactions\n"
     272 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("listunspent", "") +
         [ #  # ][ #  # ]
                 [ #  # ]
     273                 :            :             "\nLock an unspent transaction\n"
     274 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("lockunspent", "false \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
         [ #  # ][ #  # ]
                 [ #  # ]
     275                 :            :             "\nList the locked transactions\n"
     276 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("listlockunspent", "") +
         [ #  # ][ #  # ]
                 [ #  # ]
     277                 :            :             "\nUnlock the transaction again\n"
     278 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("lockunspent", "true \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
         [ #  # ][ #  # ]
                 [ #  # ]
     279                 :            :             "\nLock the transaction persistently in the wallet database\n"
     280 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("lockunspent", "false \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\" true") +
         [ #  # ][ #  # ]
                 [ #  # ]
     281                 :            :             "\nAs a JSON-RPC call\n"
     282 [ #  # ][ #  # ]:          0 :             + HelpExampleRpc("lockunspent", "false, \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"")
         [ #  # ][ #  # ]
     283                 :            :                 },
     284                 :          0 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     285                 :            : {
     286                 :          0 :     std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
     287 [ #  # ][ #  # ]:          0 :     if (!pwallet) return UniValue::VNULL;
     288                 :            : 
     289                 :            :     // Make sure the results are valid at least up to the most recent block
     290                 :            :     // the user could have gotten from another RPC command prior to now
     291         [ #  # ]:          0 :     pwallet->BlockUntilSyncedToCurrentChain();
     292                 :            : 
     293         [ #  # ]:          0 :     LOCK(pwallet->cs_wallet);
     294                 :            : 
     295 [ #  # ][ #  # ]:          0 :     bool fUnlock = request.params[0].get_bool();
     296                 :            : 
     297 [ #  # ][ #  # ]:          0 :     const bool persistent{request.params[2].isNull() ? false : request.params[2].get_bool()};
         [ #  # ][ #  # ]
     298                 :            : 
     299 [ #  # ][ #  # ]:          0 :     if (request.params[1].isNull()) {
     300         [ #  # ]:          0 :         if (fUnlock) {
     301 [ #  # ][ #  # ]:          0 :             if (!pwallet->UnlockAllCoins())
     302 [ #  # ][ #  # ]:          0 :                 throw JSONRPCError(RPC_WALLET_ERROR, "Unlocking coins failed");
                 [ #  # ]
     303                 :          0 :         }
     304         [ #  # ]:          0 :         return true;
     305                 :            :     }
     306                 :            : 
     307 [ #  # ][ #  # ]:          0 :     const UniValue& output_params = request.params[1].get_array();
     308                 :            : 
     309                 :            :     // Create and validate the COutPoints first.
     310                 :            : 
     311                 :          0 :     std::vector<COutPoint> outputs;
     312 [ #  # ][ #  # ]:          0 :     outputs.reserve(output_params.size());
     313                 :            : 
     314 [ #  # ][ #  # ]:          0 :     for (unsigned int idx = 0; idx < output_params.size(); idx++) {
     315 [ #  # ][ #  # ]:          0 :         const UniValue& o = output_params[idx].get_obj();
     316                 :            : 
     317         [ #  # ]:          0 :         RPCTypeCheckObj(o,
     318         [ #  # ]:          0 :             {
     319 [ #  # ][ #  # ]:          0 :                 {"txid", UniValueType(UniValue::VSTR)},
     320 [ #  # ][ #  # ]:          0 :                 {"vout", UniValueType(UniValue::VNUM)},
     321                 :            :             });
     322                 :            : 
     323 [ #  # ][ #  # ]:          0 :         const uint256 txid(ParseHashO(o, "txid"));
     324 [ #  # ][ #  # ]:          0 :         const int nOutput = o.find_value("vout").getInt<int>();
     325         [ #  # ]:          0 :         if (nOutput < 0) {
     326 [ #  # ][ #  # ]:          0 :             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout cannot be negative");
                 [ #  # ]
     327                 :            :         }
     328                 :            : 
     329         [ #  # ]:          0 :         const COutPoint outpt(txid, nOutput);
     330                 :            : 
     331         [ #  # ]:          0 :         const auto it = pwallet->mapWallet.find(outpt.hash);
     332         [ #  # ]:          0 :         if (it == pwallet->mapWallet.end()) {
     333 [ #  # ][ #  # ]:          0 :             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, unknown transaction");
                 [ #  # ]
     334                 :            :         }
     335                 :            : 
     336                 :          0 :         const CWalletTx& trans = it->second;
     337                 :            : 
     338         [ #  # ]:          0 :         if (outpt.n >= trans.tx->vout.size()) {
     339 [ #  # ][ #  # ]:          0 :             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout index out of bounds");
                 [ #  # ]
     340                 :            :         }
     341                 :            : 
     342 [ #  # ][ #  # ]:          0 :         if (pwallet->IsSpent(outpt)) {
     343 [ #  # ][ #  # ]:          0 :             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected unspent output");
                 [ #  # ]
     344                 :            :         }
     345                 :            : 
     346         [ #  # ]:          0 :         const bool is_locked = pwallet->IsLockedCoin(outpt);
     347                 :            : 
     348 [ #  # ][ #  # ]:          0 :         if (fUnlock && !is_locked) {
     349 [ #  # ][ #  # ]:          0 :             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected locked output");
                 [ #  # ]
     350                 :            :         }
     351                 :            : 
     352 [ #  # ][ #  # ]:          0 :         if (!fUnlock && is_locked && !persistent) {
                 [ #  # ]
     353 [ #  # ][ #  # ]:          0 :             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, output already locked");
                 [ #  # ]
     354                 :            :         }
     355                 :            : 
     356         [ #  # ]:          0 :         outputs.push_back(outpt);
     357                 :          0 :     }
     358                 :            : 
     359                 :          0 :     std::unique_ptr<WalletBatch> batch = nullptr;
     360                 :            :     // Unlock is always persistent
     361 [ #  # ][ #  # ]:          0 :     if (fUnlock || persistent) batch = std::make_unique<WalletBatch>(pwallet->GetDatabase());
         [ #  # ][ #  # ]
     362                 :            : 
     363                 :            :     // Atomically set (un)locked status for the outputs.
     364         [ #  # ]:          0 :     for (const COutPoint& outpt : outputs) {
     365         [ #  # ]:          0 :         if (fUnlock) {
     366 [ #  # ][ #  # ]:          0 :             if (!pwallet->UnlockCoin(outpt, batch.get())) throw JSONRPCError(RPC_WALLET_ERROR, "Unlocking coin failed");
         [ #  # ][ #  # ]
                 [ #  # ]
     367                 :          0 :         } else {
     368 [ #  # ][ #  # ]:          0 :             if (!pwallet->LockCoin(outpt, batch.get())) throw JSONRPCError(RPC_WALLET_ERROR, "Locking coin failed");
         [ #  # ][ #  # ]
                 [ #  # ]
     369                 :            :         }
     370                 :            :     }
     371                 :            : 
     372         [ #  # ]:          0 :     return true;
     373                 :          0 : },
     374                 :            :     };
     375                 :          0 : }
     376                 :            : 
     377                 :          0 : RPCHelpMan listlockunspent()
     378                 :            : {
     379 [ #  # ][ #  # ]:          0 :     return RPCHelpMan{"listlockunspent",
         [ #  # ][ #  # ]
     380         [ #  # ]:          0 :                 "\nReturns list of temporarily unspendable outputs.\n"
     381                 :            :                 "See the lockunspent call to lock and unlock transactions for spending.\n",
     382                 :          0 :                 {},
     383 [ #  # ][ #  # ]:          0 :                 RPCResult{
     384 [ #  # ][ #  # ]:          0 :                     RPCResult::Type::ARR, "", "",
     385         [ #  # ]:          0 :                     {
     386 [ #  # ][ #  # ]:          0 :                         {RPCResult::Type::OBJ, "", "",
                 [ #  # ]
     387         [ #  # ]:          0 :                         {
     388 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::STR_HEX, "txid", "The transaction id locked"},
                 [ #  # ]
     389 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::NUM, "vout", "The vout value"},
                 [ #  # ]
     390                 :            :                         }},
     391                 :            :                     }
     392                 :            :                 },
     393         [ #  # ]:          0 :                 RPCExamples{
     394                 :            :             "\nList the unspent transactions\n"
     395 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("listunspent", "") +
         [ #  # ][ #  # ]
                 [ #  # ]
     396                 :            :             "\nLock an unspent transaction\n"
     397 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("lockunspent", "false \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
         [ #  # ][ #  # ]
                 [ #  # ]
     398                 :            :             "\nList the locked transactions\n"
     399 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("listlockunspent", "") +
         [ #  # ][ #  # ]
                 [ #  # ]
     400                 :            :             "\nUnlock the transaction again\n"
     401 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("lockunspent", "true \"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":1}]\"") +
         [ #  # ][ #  # ]
                 [ #  # ]
     402                 :            :             "\nAs a JSON-RPC call\n"
     403 [ #  # ][ #  # ]:          0 :             + HelpExampleRpc("listlockunspent", "")
         [ #  # ][ #  # ]
     404                 :            :                 },
     405                 :          0 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     406                 :            : {
     407                 :          0 :     const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
     408 [ #  # ][ #  # ]:          0 :     if (!pwallet) return UniValue::VNULL;
     409                 :            : 
     410         [ #  # ]:          0 :     LOCK(pwallet->cs_wallet);
     411                 :            : 
     412                 :          0 :     std::vector<COutPoint> vOutpts;
     413         [ #  # ]:          0 :     pwallet->ListLockedCoins(vOutpts);
     414                 :            : 
     415         [ #  # ]:          0 :     UniValue ret(UniValue::VARR);
     416                 :            : 
     417         [ #  # ]:          0 :     for (const COutPoint& outpt : vOutpts) {
     418         [ #  # ]:          0 :         UniValue o(UniValue::VOBJ);
     419                 :            : 
     420 [ #  # ][ #  # ]:          0 :         o.pushKV("txid", outpt.hash.GetHex());
         [ #  # ][ #  # ]
     421 [ #  # ][ #  # ]:          0 :         o.pushKV("vout", (int)outpt.n);
                 [ #  # ]
     422 [ #  # ][ #  # ]:          0 :         ret.push_back(o);
     423                 :          0 :     }
     424                 :            : 
     425                 :          0 :     return ret;
     426         [ #  # ]:          0 : },
     427                 :            :     };
     428                 :          0 : }
     429                 :            : 
     430                 :          0 : RPCHelpMan getbalances()
     431                 :            : {
     432 [ #  # ][ #  # ]:          0 :     return RPCHelpMan{
         [ #  # ][ #  # ]
     433         [ #  # ]:          0 :         "getbalances",
     434 [ #  # ][ #  # ]:          0 :         "Returns an object with all balances in " + CURRENCY_UNIT + ".\n",
     435                 :          0 :         {},
     436 [ #  # ][ #  # ]:          0 :         RPCResult{
     437 [ #  # ][ #  # ]:          0 :             RPCResult::Type::OBJ, "", "",
     438         [ #  # ]:          0 :             {
     439 [ #  # ][ #  # ]:          0 :                 {RPCResult::Type::OBJ, "mine", "balances from outputs that the wallet can sign",
                 [ #  # ]
     440         [ #  # ]:          0 :                 {
     441 [ #  # ][ #  # ]:          0 :                     {RPCResult::Type::STR_AMOUNT, "trusted", "trusted balance (outputs created by the wallet or confirmed outputs)"},
                 [ #  # ]
     442 [ #  # ][ #  # ]:          0 :                     {RPCResult::Type::STR_AMOUNT, "untrusted_pending", "untrusted pending balance (outputs created by others that are in the mempool)"},
                 [ #  # ]
     443 [ #  # ][ #  # ]:          0 :                     {RPCResult::Type::STR_AMOUNT, "immature", "balance from immature coinbase outputs"},
                 [ #  # ]
     444 [ #  # ][ #  # ]:          0 :                     {RPCResult::Type::STR_AMOUNT, "used", /*optional=*/true, "(only present if avoid_reuse is set) balance from coins sent to addresses that were previously spent from (potentially privacy violating)"},
                 [ #  # ]
     445                 :            :                 }},
     446 [ #  # ][ #  # ]:          0 :                 {RPCResult::Type::OBJ, "watchonly", /*optional=*/true, "watchonly balances (not present if wallet does not watch anything)",
                 [ #  # ]
     447         [ #  # ]:          0 :                 {
     448 [ #  # ][ #  # ]:          0 :                     {RPCResult::Type::STR_AMOUNT, "trusted", "trusted balance (outputs created by the wallet or confirmed outputs)"},
                 [ #  # ]
     449 [ #  # ][ #  # ]:          0 :                     {RPCResult::Type::STR_AMOUNT, "untrusted_pending", "untrusted pending balance (outputs created by others that are in the mempool)"},
                 [ #  # ]
     450 [ #  # ][ #  # ]:          0 :                     {RPCResult::Type::STR_AMOUNT, "immature", "balance from immature coinbase outputs"},
                 [ #  # ]
     451                 :            :                 }},
     452         [ #  # ]:          0 :                 RESULT_LAST_PROCESSED_BLOCK,
     453                 :            :             }
     454                 :            :             },
     455         [ #  # ]:          0 :         RPCExamples{
     456 [ #  # ][ #  # ]:          0 :             HelpExampleCli("getbalances", "") +
         [ #  # ][ #  # ]
     457 [ #  # ][ #  # ]:          0 :             HelpExampleRpc("getbalances", "")},
                 [ #  # ]
     458                 :          0 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     459                 :            : {
     460                 :          0 :     const std::shared_ptr<const CWallet> rpc_wallet = GetWalletForJSONRPCRequest(request);
     461 [ #  # ][ #  # ]:          0 :     if (!rpc_wallet) return UniValue::VNULL;
     462                 :          0 :     const CWallet& wallet = *rpc_wallet;
     463                 :            : 
     464                 :            :     // Make sure the results are valid at least up to the most recent block
     465                 :            :     // the user could have gotten from another RPC command prior to now
     466         [ #  # ]:          0 :     wallet.BlockUntilSyncedToCurrentChain();
     467                 :            : 
     468         [ #  # ]:          0 :     LOCK(wallet.cs_wallet);
     469                 :            : 
     470         [ #  # ]:          0 :     const auto bal = GetBalance(wallet);
     471         [ #  # ]:          0 :     UniValue balances{UniValue::VOBJ};
     472                 :            :     {
     473         [ #  # ]:          0 :         UniValue balances_mine{UniValue::VOBJ};
     474 [ #  # ][ #  # ]:          0 :         balances_mine.pushKV("trusted", ValueFromAmount(bal.m_mine_trusted));
                 [ #  # ]
     475 [ #  # ][ #  # ]:          0 :         balances_mine.pushKV("untrusted_pending", ValueFromAmount(bal.m_mine_untrusted_pending));
                 [ #  # ]
     476 [ #  # ][ #  # ]:          0 :         balances_mine.pushKV("immature", ValueFromAmount(bal.m_mine_immature));
                 [ #  # ]
     477 [ #  # ][ #  # ]:          0 :         if (wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
     478                 :            :             // If the AVOID_REUSE flag is set, bal has been set to just the un-reused address balance. Get
     479                 :            :             // the total balance, and then subtract bal to get the reused address balance.
     480         [ #  # ]:          0 :             const auto full_bal = GetBalance(wallet, 0, false);
     481 [ #  # ][ #  # ]:          0 :             balances_mine.pushKV("used", ValueFromAmount(full_bal.m_mine_trusted + full_bal.m_mine_untrusted_pending - bal.m_mine_trusted - bal.m_mine_untrusted_pending));
                 [ #  # ]
     482                 :          0 :         }
     483 [ #  # ][ #  # ]:          0 :         balances.pushKV("mine", balances_mine);
                 [ #  # ]
     484                 :          0 :     }
     485         [ #  # ]:          0 :     auto spk_man = wallet.GetLegacyScriptPubKeyMan();
     486 [ #  # ][ #  # ]:          0 :     if (spk_man && spk_man->HaveWatchOnly()) {
                 [ #  # ]
     487         [ #  # ]:          0 :         UniValue balances_watchonly{UniValue::VOBJ};
     488 [ #  # ][ #  # ]:          0 :         balances_watchonly.pushKV("trusted", ValueFromAmount(bal.m_watchonly_trusted));
                 [ #  # ]
     489 [ #  # ][ #  # ]:          0 :         balances_watchonly.pushKV("untrusted_pending", ValueFromAmount(bal.m_watchonly_untrusted_pending));
                 [ #  # ]
     490 [ #  # ][ #  # ]:          0 :         balances_watchonly.pushKV("immature", ValueFromAmount(bal.m_watchonly_immature));
                 [ #  # ]
     491 [ #  # ][ #  # ]:          0 :         balances.pushKV("watchonly", balances_watchonly);
                 [ #  # ]
     492                 :          0 :     }
     493                 :            : 
     494         [ #  # ]:          0 :     AppendLastProcessedBlock(balances, wallet);
     495                 :          0 :     return balances;
     496         [ #  # ]:          0 : },
     497                 :            :     };
     498                 :          0 : }
     499                 :            : 
     500                 :          0 : RPCHelpMan listunspent()
     501                 :            : {
     502 [ #  # ][ #  # ]:          0 :     return RPCHelpMan{
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
     503         [ #  # ]:          0 :                 "listunspent",
     504         [ #  # ]:          0 :                 "\nReturns array of unspent transaction outputs\n"
     505                 :            :                 "with between minconf and maxconf (inclusive) confirmations.\n"
     506                 :            :                 "Optionally filter to only include txouts paid to specified addresses.\n",
     507         [ #  # ]:          0 :                 {
     508 [ #  # ][ #  # ]:          0 :                     {"minconf", RPCArg::Type::NUM, RPCArg::Default{1}, "The minimum confirmations to filter"},
         [ #  # ][ #  # ]
     509 [ #  # ][ #  # ]:          0 :                     {"maxconf", RPCArg::Type::NUM, RPCArg::Default{9999999}, "The maximum confirmations to filter"},
         [ #  # ][ #  # ]
     510 [ #  # ][ #  # ]:          0 :                     {"addresses", RPCArg::Type::ARR, RPCArg::Default{UniValue::VARR}, "The bitcoin addresses to filter",
         [ #  # ][ #  # ]
     511         [ #  # ]:          0 :                         {
     512 [ #  # ][ #  # ]:          0 :                             {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "bitcoin address"},
                 [ #  # ]
     513                 :            :                         },
     514                 :            :                     },
     515 [ #  # ][ #  # ]:          0 :                     {"include_unsafe", RPCArg::Type::BOOL, RPCArg::Default{true}, "Include outputs that are not safe to spend\n"
         [ #  # ][ #  # ]
     516                 :            :                               "See description of \"safe\" attribute below."},
     517 [ #  # ][ #  # ]:          0 :                     {"query_options", RPCArg::Type::OBJ_NAMED_PARAMS, RPCArg::Optional::OMITTED, "",
                 [ #  # ]
     518         [ #  # ]:          0 :                         {
     519 [ #  # ][ #  # ]:          0 :                             {"minimumAmount", RPCArg::Type::AMOUNT, RPCArg::Default{FormatMoney(0)}, "Minimum value of each UTXO in " + CURRENCY_UNIT + ""},
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     520 [ #  # ][ #  # ]:          0 :                             {"maximumAmount", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"unlimited"}, "Maximum value of each UTXO in " + CURRENCY_UNIT + ""},
         [ #  # ][ #  # ]
                 [ #  # ]
     521 [ #  # ][ #  # ]:          0 :                             {"maximumCount", RPCArg::Type::NUM, RPCArg::DefaultHint{"unlimited"}, "Maximum number of UTXOs"},
         [ #  # ][ #  # ]
     522 [ #  # ][ #  # ]:          0 :                             {"minimumSumAmount", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"unlimited"}, "Minimum sum value of all UTXOs in " + CURRENCY_UNIT + ""},
         [ #  # ][ #  # ]
                 [ #  # ]
     523 [ #  # ][ #  # ]:          0 :                             {"include_immature_coinbase", RPCArg::Type::BOOL, RPCArg::Default{false}, "Include immature coinbase UTXOs"}
         [ #  # ][ #  # ]
     524                 :            :                         },
     525         [ #  # ]:          0 :                         RPCArgOptions{.oneline_description="query_options"}},
     526                 :            :                 },
     527 [ #  # ][ #  # ]:          0 :                 RPCResult{
     528 [ #  # ][ #  # ]:          0 :                     RPCResult::Type::ARR, "", "",
     529         [ #  # ]:          0 :                     {
     530 [ #  # ][ #  # ]:          0 :                         {RPCResult::Type::OBJ, "", "",
                 [ #  # ]
     531         [ #  # ]:          0 :                         {
     532 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::STR_HEX, "txid", "the transaction id"},
                 [ #  # ]
     533 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::NUM, "vout", "the vout value"},
                 [ #  # ]
     534 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::STR, "address", /*optional=*/true, "the bitcoin address"},
                 [ #  # ]
     535 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::STR, "label", /*optional=*/true, "The associated label, or \"\" for the default label"},
                 [ #  # ]
     536 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::STR, "scriptPubKey", "the script key"},
                 [ #  # ]
     537 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::STR_AMOUNT, "amount", "the transaction output amount in " + CURRENCY_UNIT},
                 [ #  # ]
     538 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::NUM, "confirmations", "The number of confirmations"},
                 [ #  # ]
     539 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::NUM, "ancestorcount", /*optional=*/true, "The number of in-mempool ancestor transactions, including this one (if transaction is in the mempool)"},
                 [ #  # ]
     540 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::NUM, "ancestorsize", /*optional=*/true, "The virtual transaction size of in-mempool ancestors, including this one (if transaction is in the mempool)"},
                 [ #  # ]
     541 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::STR_AMOUNT, "ancestorfees", /*optional=*/true, "The total fees of in-mempool ancestors (including this one) with fee deltas used for mining priority in " + CURRENCY_ATOM + " (if transaction is in the mempool)"},
         [ #  # ][ #  # ]
     542 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::STR_HEX, "redeemScript", /*optional=*/true, "The redeemScript if scriptPubKey is P2SH"},
                 [ #  # ]
     543 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::STR, "witnessScript", /*optional=*/true, "witnessScript if the scriptPubKey is P2WSH or P2SH-P2WSH"},
                 [ #  # ]
     544 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::BOOL, "spendable", "Whether we have the private keys to spend this output"},
                 [ #  # ]
     545 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::BOOL, "solvable", "Whether we know how to spend this output, ignoring the lack of keys"},
                 [ #  # ]
     546 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::BOOL, "reused", /*optional=*/true, "(only present if avoid_reuse is set) Whether this output is reused/dirty (sent to an address that was previously spent from)"},
                 [ #  # ]
     547 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::STR, "desc", /*optional=*/true, "(only when solvable) A descriptor for spending this output"},
                 [ #  # ]
     548 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::ARR, "parent_descs", /*optional=*/false, "List of parent descriptors for the scriptPubKey of this coin.", {
         [ #  # ][ #  # ]
     549 [ #  # ][ #  # ]:          0 :                                 {RPCResult::Type::STR, "desc", "The descriptor string."},
                 [ #  # ]
     550                 :            :                             }},
     551 [ #  # ][ #  # ]:          0 :                             {RPCResult::Type::BOOL, "safe", "Whether this output is considered safe to spend. Unconfirmed transactions\n"
                 [ #  # ]
     552                 :            :                                                             "from outside keys and unconfirmed replacement transactions are considered unsafe\n"
     553                 :            :                                                             "and are not eligible for spending by fundrawtransaction and sendtoaddress."},
     554                 :            :                         }},
     555                 :            :                     }
     556                 :            :                 },
     557         [ #  # ]:          0 :                 RPCExamples{
     558 [ #  # ][ #  # ]:          0 :                     HelpExampleCli("listunspent", "")
                 [ #  # ]
     559 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("listunspent", "6 9999999 \"[\\\"" + EXAMPLE_ADDRESS[0] + "\\\",\\\"" + EXAMPLE_ADDRESS[1] + "\\\"]\"")
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
     560 [ #  # ][ #  # ]:          0 :             + HelpExampleRpc("listunspent", "6, 9999999 \"[\\\"" + EXAMPLE_ADDRESS[0] + "\\\",\\\"" + EXAMPLE_ADDRESS[1] + "\\\"]\"")
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
     561 [ #  # ][ #  # ]:          0 :             + HelpExampleCli("listunspent", "6 9999999 '[]' true '{ \"minimumAmount\": 0.005 }'")
         [ #  # ][ #  # ]
     562 [ #  # ][ #  # ]:          0 :             + HelpExampleRpc("listunspent", "6, 9999999, [] , true, { \"minimumAmount\": 0.005 } ")
         [ #  # ][ #  # ]
     563                 :            :                 },
     564                 :          0 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     565                 :            : {
     566                 :          0 :     const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
     567 [ #  # ][ #  # ]:          0 :     if (!pwallet) return UniValue::VNULL;
     568                 :            : 
     569                 :          0 :     int nMinDepth = 1;
     570 [ #  # ][ #  # ]:          0 :     if (!request.params[0].isNull()) {
     571 [ #  # ][ #  # ]:          0 :         nMinDepth = request.params[0].getInt<int>();
     572                 :          0 :     }
     573                 :            : 
     574                 :          0 :     int nMaxDepth = 9999999;
     575 [ #  # ][ #  # ]:          0 :     if (!request.params[1].isNull()) {
     576 [ #  # ][ #  # ]:          0 :         nMaxDepth = request.params[1].getInt<int>();
     577                 :          0 :     }
     578                 :            : 
     579                 :          0 :     std::set<CTxDestination> destinations;
     580 [ #  # ][ #  # ]:          0 :     if (!request.params[2].isNull()) {
     581 [ #  # ][ #  # ]:          0 :         UniValue inputs = request.params[2].get_array();
                 [ #  # ]
     582         [ #  # ]:          0 :         for (unsigned int idx = 0; idx < inputs.size(); idx++) {
     583         [ #  # ]:          0 :             const UniValue& input = inputs[idx];
     584 [ #  # ][ #  # ]:          0 :             CTxDestination dest = DecodeDestination(input.get_str());
     585 [ #  # ][ #  # ]:          0 :             if (!IsValidDestination(dest)) {
     586 [ #  # ][ #  # ]:          0 :                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Bitcoin address: ") + input.get_str());
         [ #  # ][ #  # ]
                 [ #  # ]
     587                 :            :             }
     588 [ #  # ][ #  # ]:          0 :             if (!destinations.insert(dest).second) {
     589 [ #  # ][ #  # ]:          0 :                 throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ") + input.get_str());
         [ #  # ][ #  # ]
                 [ #  # ]
     590                 :            :             }
     591                 :          0 :         }
     592                 :          0 :     }
     593                 :            : 
     594                 :          0 :     bool include_unsafe = true;
     595 [ #  # ][ #  # ]:          0 :     if (!request.params[3].isNull()) {
     596 [ #  # ][ #  # ]:          0 :         include_unsafe = request.params[3].get_bool();
     597                 :          0 :     }
     598                 :            : 
     599                 :          0 :     CoinFilterParams filter_coins;
     600                 :          0 :     filter_coins.min_amount = 0;
     601                 :            : 
     602 [ #  # ][ #  # ]:          0 :     if (!request.params[4].isNull()) {
     603 [ #  # ][ #  # ]:          0 :         const UniValue& options = request.params[4].get_obj();
     604                 :            : 
     605         [ #  # ]:          0 :         RPCTypeCheckObj(options,
     606         [ #  # ]:          0 :             {
     607 [ #  # ][ #  # ]:          0 :                 {"minimumAmount", UniValueType()},
     608 [ #  # ][ #  # ]:          0 :                 {"maximumAmount", UniValueType()},
     609 [ #  # ][ #  # ]:          0 :                 {"minimumSumAmount", UniValueType()},
     610 [ #  # ][ #  # ]:          0 :                 {"maximumCount", UniValueType(UniValue::VNUM)},
     611 [ #  # ][ #  # ]:          0 :                 {"include_immature_coinbase", UniValueType(UniValue::VBOOL)}
     612                 :            :             },
     613                 :            :             true, true);
     614                 :            : 
     615 [ #  # ][ #  # ]:          0 :         if (options.exists("minimumAmount"))
                 [ #  # ]
     616 [ #  # ][ #  # ]:          0 :             filter_coins.min_amount = AmountFromValue(options["minimumAmount"]);
                 [ #  # ]
     617                 :            : 
     618 [ #  # ][ #  # ]:          0 :         if (options.exists("maximumAmount"))
                 [ #  # ]
     619 [ #  # ][ #  # ]:          0 :             filter_coins.max_amount = AmountFromValue(options["maximumAmount"]);
                 [ #  # ]
     620                 :            : 
     621 [ #  # ][ #  # ]:          0 :         if (options.exists("minimumSumAmount"))
                 [ #  # ]
     622 [ #  # ][ #  # ]:          0 :             filter_coins.min_sum_amount = AmountFromValue(options["minimumSumAmount"]);
                 [ #  # ]
     623                 :            : 
     624 [ #  # ][ #  # ]:          0 :         if (options.exists("maximumCount"))
                 [ #  # ]
     625 [ #  # ][ #  # ]:          0 :             filter_coins.max_count = options["maximumCount"].getInt<int64_t>();
                 [ #  # ]
     626                 :            : 
     627 [ #  # ][ #  # ]:          0 :         if (options.exists("include_immature_coinbase")) {
                 [ #  # ]
     628 [ #  # ][ #  # ]:          0 :             filter_coins.include_immature_coinbase = options["include_immature_coinbase"].get_bool();
                 [ #  # ]
     629                 :          0 :         }
     630                 :          0 :     }
     631                 :            : 
     632                 :            :     // Make sure the results are valid at least up to the most recent block
     633                 :            :     // the user could have gotten from another RPC command prior to now
     634         [ #  # ]:          0 :     pwallet->BlockUntilSyncedToCurrentChain();
     635                 :            : 
     636         [ #  # ]:          0 :     UniValue results(UniValue::VARR);
     637                 :          0 :     std::vector<COutput> vecOutputs;
     638                 :            :     {
     639         [ #  # ]:          0 :         CCoinControl cctl;
     640                 :          0 :         cctl.m_avoid_address_reuse = false;
     641                 :          0 :         cctl.m_min_depth = nMinDepth;
     642                 :          0 :         cctl.m_max_depth = nMaxDepth;
     643                 :          0 :         cctl.m_include_unsafe_inputs = include_unsafe;
     644         [ #  # ]:          0 :         LOCK(pwallet->cs_wallet);
     645 [ #  # ][ #  # ]:          0 :         vecOutputs = AvailableCoinsListUnspent(*pwallet, &cctl, filter_coins).All();
     646                 :          0 :     }
     647                 :            : 
     648         [ #  # ]:          0 :     LOCK(pwallet->cs_wallet);
     649                 :            : 
     650         [ #  # ]:          0 :     const bool avoid_reuse = pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);
     651                 :            : 
     652         [ #  # ]:          0 :     for (const COutput& out : vecOutputs) {
     653         [ #  # ]:          0 :         CTxDestination address;
     654                 :          0 :         const CScript& scriptPubKey = out.txout.scriptPubKey;
     655         [ #  # ]:          0 :         bool fValidAddress = ExtractDestination(scriptPubKey, address);
     656 [ #  # ][ #  # ]:          0 :         bool reused = avoid_reuse && pwallet->IsSpentKey(scriptPubKey);
     657                 :            : 
     658 [ #  # ][ #  # ]:          0 :         if (destinations.size() && (!fValidAddress || !destinations.count(address)))
         [ #  # ][ #  # ]
     659                 :          0 :             continue;
     660                 :            : 
     661         [ #  # ]:          0 :         UniValue entry(UniValue::VOBJ);
     662 [ #  # ][ #  # ]:          0 :         entry.pushKV("txid", out.outpoint.hash.GetHex());
         [ #  # ][ #  # ]
     663 [ #  # ][ #  # ]:          0 :         entry.pushKV("vout", (int)out.outpoint.n);
                 [ #  # ]
     664                 :            : 
     665         [ #  # ]:          0 :         if (fValidAddress) {
     666 [ #  # ][ #  # ]:          0 :             entry.pushKV("address", EncodeDestination(address));
         [ #  # ][ #  # ]
     667                 :            : 
     668         [ #  # ]:          0 :             const auto* address_book_entry = pwallet->FindAddressBookEntry(address);
     669         [ #  # ]:          0 :             if (address_book_entry) {
     670 [ #  # ][ #  # ]:          0 :                 entry.pushKV("label", address_book_entry->GetLabel());
         [ #  # ][ #  # ]
     671                 :          0 :             }
     672                 :            : 
     673         [ #  # ]:          0 :             std::unique_ptr<SigningProvider> provider = pwallet->GetSolvingProvider(scriptPubKey);
     674         [ #  # ]:          0 :             if (provider) {
     675 [ #  # ][ #  # ]:          0 :                 if (scriptPubKey.IsPayToScriptHash()) {
     676 [ #  # ][ #  # ]:          0 :                     const CScriptID hash = ToScriptID(std::get<ScriptHash>(address));
     677         [ #  # ]:          0 :                     CScript redeemScript;
     678 [ #  # ][ #  # ]:          0 :                     if (provider->GetCScript(hash, redeemScript)) {
     679 [ #  # ][ #  # ]:          0 :                         entry.pushKV("redeemScript", HexStr(redeemScript));
         [ #  # ][ #  # ]
                 [ #  # ]
     680                 :            :                         // Now check if the redeemScript is actually a P2WSH script
     681         [ #  # ]:          0 :                         CTxDestination witness_destination;
     682 [ #  # ][ #  # ]:          0 :                         if (redeemScript.IsPayToWitnessScriptHash()) {
     683         [ #  # ]:          0 :                             bool extracted = ExtractDestination(redeemScript, witness_destination);
     684         [ #  # ]:          0 :                             CHECK_NONFATAL(extracted);
     685                 :            :                             // Also return the witness script
     686         [ #  # ]:          0 :                             const WitnessV0ScriptHash& whash = std::get<WitnessV0ScriptHash>(witness_destination);
     687 [ #  # ][ #  # ]:          0 :                             CScriptID id{RIPEMD160(whash)};
                 [ #  # ]
     688         [ #  # ]:          0 :                             CScript witnessScript;
     689 [ #  # ][ #  # ]:          0 :                             if (provider->GetCScript(id, witnessScript)) {
     690 [ #  # ][ #  # ]:          0 :                                 entry.pushKV("witnessScript", HexStr(witnessScript));
         [ #  # ][ #  # ]
                 [ #  # ]
     691                 :          0 :                             }
     692                 :          0 :                         }
     693                 :          0 :                     }
     694 [ #  # ][ #  # ]:          0 :                 } else if (scriptPubKey.IsPayToWitnessScriptHash()) {
     695         [ #  # ]:          0 :                     const WitnessV0ScriptHash& whash = std::get<WitnessV0ScriptHash>(address);
     696 [ #  # ][ #  # ]:          0 :                     CScriptID id{RIPEMD160(whash)};
                 [ #  # ]
     697         [ #  # ]:          0 :                     CScript witnessScript;
     698 [ #  # ][ #  # ]:          0 :                     if (provider->GetCScript(id, witnessScript)) {
     699 [ #  # ][ #  # ]:          0 :                         entry.pushKV("witnessScript", HexStr(witnessScript));
         [ #  # ][ #  # ]
                 [ #  # ]
     700                 :          0 :                     }
     701                 :          0 :                 }
     702                 :          0 :             }
     703                 :          0 :         }
     704                 :            : 
     705 [ #  # ][ #  # ]:          0 :         entry.pushKV("scriptPubKey", HexStr(scriptPubKey));
         [ #  # ][ #  # ]
                 [ #  # ]
     706 [ #  # ][ #  # ]:          0 :         entry.pushKV("amount", ValueFromAmount(out.txout.nValue));
                 [ #  # ]
     707 [ #  # ][ #  # ]:          0 :         entry.pushKV("confirmations", out.depth);
                 [ #  # ]
     708         [ #  # ]:          0 :         if (!out.depth) {
     709                 :            :             size_t ancestor_count, descendant_count, ancestor_size;
     710                 :            :             CAmount ancestor_fees;
     711 [ #  # ][ #  # ]:          0 :             pwallet->chain().getTransactionAncestry(out.outpoint.hash, ancestor_count, descendant_count, &ancestor_size, &ancestor_fees);
     712         [ #  # ]:          0 :             if (ancestor_count) {
     713 [ #  # ][ #  # ]:          0 :                 entry.pushKV("ancestorcount", uint64_t(ancestor_count));
                 [ #  # ]
     714 [ #  # ][ #  # ]:          0 :                 entry.pushKV("ancestorsize", uint64_t(ancestor_size));
                 [ #  # ]
     715 [ #  # ][ #  # ]:          0 :                 entry.pushKV("ancestorfees", uint64_t(ancestor_fees));
                 [ #  # ]
     716                 :          0 :             }
     717                 :          0 :         }
     718 [ #  # ][ #  # ]:          0 :         entry.pushKV("spendable", out.spendable);
                 [ #  # ]
     719 [ #  # ][ #  # ]:          0 :         entry.pushKV("solvable", out.solvable);
                 [ #  # ]
     720         [ #  # ]:          0 :         if (out.solvable) {
     721         [ #  # ]:          0 :             std::unique_ptr<SigningProvider> provider = pwallet->GetSolvingProvider(scriptPubKey);
     722         [ #  # ]:          0 :             if (provider) {
     723         [ #  # ]:          0 :                 auto descriptor = InferDescriptor(scriptPubKey, *provider);
     724 [ #  # ][ #  # ]:          0 :                 entry.pushKV("desc", descriptor->ToString());
         [ #  # ][ #  # ]
     725                 :          0 :             }
     726                 :          0 :         }
     727         [ #  # ]:          0 :         PushParentDescriptors(*pwallet, scriptPubKey, entry);
     728 [ #  # ][ #  # ]:          0 :         if (avoid_reuse) entry.pushKV("reused", reused);
         [ #  # ][ #  # ]
     729 [ #  # ][ #  # ]:          0 :         entry.pushKV("safe", out.safe);
                 [ #  # ]
     730 [ #  # ][ #  # ]:          0 :         results.push_back(entry);
     731         [ #  # ]:          0 :     }
     732                 :            : 
     733                 :          0 :     return results;
     734         [ #  # ]:          0 : },
     735                 :            :     };
     736                 :          0 : }
     737                 :            : } // namespace wallet

Generated by: LCOV version 1.14