LCOV - code coverage report
Current view: top level - src/wallet/rpc - coins.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 96.3 % 407 392
Test Date: 2025-08-01 05:08:13 Functions: 100.0 % 15 15
Branches: 50.8 % 1674 851

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

Generated by: LCOV version 2.0-1