1// Copyright (c) 2011-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <core_io.h>
6#include <key_io.h>
7#include <policy/rbf.h>
8#include <primitives/transaction_identifier.h>
9#include <rpc/util.h>
10#include <rpc/rawtransaction_util.h>
11#include <rpc/blockchain.h>
12#include <util/vector.h>
13#include <wallet/receive.h>
14#include <wallet/rpc/util.h>
15#include <wallet/wallet.h>
16
17using interfaces::FoundBlock;
18
19namespace wallet {
20static void WalletTxToJSON(const CWallet& wallet, const CWalletTx& wtx, UniValue& entry)
21    EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
22{
23    interfaces::Chain& chain = wallet.chain();
24    int confirms = wallet.GetTxDepthInMainChain(wtx);
25    entry.pushKV("confirmations", confirms);
26    if (wtx.IsCoinBase())
27        entry.pushKV("generated", true);
28    if (auto* conf = wtx.state<TxStateConfirmed>())
29    {
30        entry.pushKV("blockhash", conf->confirmed_block_hash.GetHex());
31        entry.pushKV("blockheight", conf->confirmed_block_height);
32        entry.pushKV("blockindex", conf->position_in_block);
33        int64_t block_time;
34        CHECK_NONFATAL(chain.findBlock(conf->confirmed_block_hash, FoundBlock().time(block_time)));
35        entry.pushKV("blocktime", block_time);
36    } else {
37        entry.pushKV("trusted", CachedTxIsTrusted(wallet, wtx));
38    }
39    entry.pushKV("txid", wtx.GetHash().GetHex());
40    entry.pushKV("wtxid", wtx.GetWitnessHash().GetHex());
41    UniValue alternate_wtxids(UniValue::VARR);
42    for (const auto& [wtxid, _] : wtx.GetTxs()) {
43        if (wtxid == wtx.GetWitnessHash()) continue;
44        alternate_wtxids.push_back(wtxid.GetHex());
45    }
46    entry.pushKV("alternate_wtxids", alternate_wtxids);
47    UniValue conflicts(UniValue::VARR);
48    for (const Txid& conflict : wallet.GetTxConflicts(wtx))
49        conflicts.push_back(conflict.GetHex());
50    entry.pushKV("walletconflicts", std::move(conflicts));
51    UniValue mempool_conflicts(UniValue::VARR);
52    for (const Txid& mempool_conflict : wtx.mempool_conflicts)
53        mempool_conflicts.push_back(mempool_conflict.GetHex());
54    entry.pushKV("mempoolconflicts", std::move(mempool_conflicts));
55    entry.pushKV("time", wtx.GetTxTime());
56    entry.pushKV("timereceived", wtx.nTimeReceived);
57
58    // Add opt-in RBF status
59    if (chain.rpcEnableDeprecated("bip125")) {
60        std::string rbfStatus = "no";
61        if (confirms <= 0) {
62            RBFTransactionState rbfState = chain.isRBFOptIn(*wtx.GetTx());
63            if (rbfState == RBFTransactionState::UNKNOWN)
64                rbfStatus = "unknown";
65            else if (rbfState == RBFTransactionState::REPLACEABLE_BIP125)
66                rbfStatus = "yes";
67        }
68        entry.pushKV("bip125-replaceable", rbfStatus);
69    }
70
71    if (wtx.m_comment) entry.pushKV("comment", *wtx.m_comment);
72    if (wtx.m_comment_to) entry.pushKV("to", *wtx.m_comment_to);
73    if (wtx.m_replaces_txid) entry.pushKV("replaces_txid", wtx.m_replaces_txid->ToString());
74    if (wtx.m_replaced_by_txid) entry.pushKV("replaced_by_txid", wtx.m_replaced_by_txid->ToString());
75}
76
77struct tallyitem
78{
79    CAmount nAmount{0};
80    int nConf{std::numeric_limits<int>::max()};
81    std::vector<Txid> txids;
82    tallyitem() = default;
83};
84
85static UniValue ListReceived(const CWallet& wallet, const UniValue& params, const bool by_label, const bool include_immature_coinbase) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
86{
87    // Minimum confirmations
88    int nMinDepth = 1;
89    if (!params[0].isNull())
90        nMinDepth = params[0].getInt<int>();
91
92    // Whether to include empty labels
93    bool fIncludeEmpty = false;
94    if (!params[1].isNull())
95        fIncludeEmpty = params[1].get_bool();
96
97    std::optional<CTxDestination> filtered_address{std::nullopt};
98    if (!by_label && !params[3].isNull() && !params[3].get_str().empty()) {
99        if (!IsValidDestinationString(params[3].get_str())) {
100            throw JSONRPCError(RPC_WALLET_ERROR, "address_filter parameter was invalid");
101        }
102        filtered_address = DecodeDestination(params[3].get_str());
103    }
104
105    // Tally
106    std::map<CTxDestination, tallyitem> mapTally;
107    for (const auto& [_, wtx] : wallet.mapWallet) {
108
109        int nDepth = wallet.GetTxDepthInMainChain(wtx);
110        if (nDepth < nMinDepth)
111            continue;
112
113        // Coinbase with less than 1 confirmation is no longer in the main chain
114        if ((wtx.IsCoinBase() && (nDepth < 1))
115            || (wallet.IsTxImmatureCoinBase(wtx) && !include_immature_coinbase)) {
116            continue;
117        }
118
119        for (const CTxOut& txout : wtx.GetTx()->vout) {
120            CTxDestination address;
121            if (!ExtractDestination(txout.scriptPubKey, address))
122                continue;
123
124            if (filtered_address && !(filtered_address == address)) {
125                continue;
126            }
127
128            if (!wallet.IsMine(address))
129                continue;
130
131            tallyitem& item = mapTally[address];
132            item.nAmount += txout.nValue;
133            item.nConf = std::min(item.nConf, nDepth);
134            item.txids.push_back(wtx.GetHash());
135        }
136    }
137
138    // Reply
139    UniValue ret(UniValue::VARR);
140    std::map<std::string, tallyitem> label_tally;
141
142    const auto& func = [&](const CTxDestination& address, const std::string& label, bool is_change,
143                            const std::optional<AddressPurpose>& purpose) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet) {
144        if (is_change) return; // no change addresses
145
146        // Entries in mapTally are only ever added for wallet.IsMine() addresses (see the tally
147        // loop above), so it's only addresses missing from mapTally that need the IsMine() check.
148        auto it = mapTally.find(address);
149        if (it == mapTally.end()) {
150            if (!fIncludeEmpty) return;
151            if (!wallet.IsMine(address)) return; // exclude addresses not owned by the wallet (e.g. "send" purpose)
152        }
153
154        CAmount nAmount = 0;
155        int nConf = std::numeric_limits<int>::max();
156        if (it != mapTally.end()) {
157            nAmount = (*it).second.nAmount;
158            nConf = (*it).second.nConf;
159        }
160
161        if (by_label) {
162            tallyitem& _item = label_tally[label];
163            _item.nAmount += nAmount;
164            _item.nConf = std::min(_item.nConf, nConf);
165        } else {
166            UniValue obj(UniValue::VOBJ);
167            obj.pushKV("address",       EncodeDestination(address));
168            obj.pushKV("amount",        ValueFromAmount(nAmount));
169            obj.pushKV("confirmations", (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
170            obj.pushKV("label", label);
171            UniValue transactions(UniValue::VARR);
172            if (it != mapTally.end()) {
173                for (const Txid& _item : (*it).second.txids) {
174                    transactions.push_back(_item.GetHex());
175                }
176            }
177            obj.pushKV("txids", std::move(transactions));
178            ret.push_back(std::move(obj));
179        }
180    };
181
182    if (filtered_address) {
183        const auto& entry = wallet.FindAddressBookEntry(*filtered_address, /*allow_change=*/false);
184        if (entry) func(*filtered_address, entry->GetLabel(), entry->IsChange(), entry->purpose);
185    } else {
186        // No filtered addr, walk-through the addressbook entry
187        wallet.ForEachAddrBookEntry(func);
188    }
189
190    if (by_label) {
191        for (const auto& entry : label_tally) {
192            CAmount nAmount = entry.second.nAmount;
193            int nConf = entry.second.nConf;
194            UniValue obj(UniValue::VOBJ);
195            obj.pushKV("amount",        ValueFromAmount(nAmount));
196            obj.pushKV("confirmations", (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
197            obj.pushKV("label",         entry.first);
198            ret.push_back(std::move(obj));
199        }
200    }
201
202    return ret;
203}
204
205RPCMethod listreceivedbyaddress()
206{
207    return RPCMethod{
208        "listreceivedbyaddress",
209        "List balances by receiving address.\n",
210                {
211                    {"minconf", RPCArg::Type::NUM, RPCArg::Default{1}, "The minimum number of confirmations before payments are included."},
212                    {"include_empty", RPCArg::Type::BOOL, RPCArg::Default{false}, "Whether to include addresses that haven't received any payments."},
213                    {"include_watchonly", RPCArg::Type::BOOL, RPCArg::Default{false}, "(DEPRECATED) No longer used"},
214                    {"address_filter", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "If present and non-empty, only return information on this address."},
215                    {"include_immature_coinbase", RPCArg::Type::BOOL, RPCArg::Default{false}, "Include immature coinbase transactions."},
216                },
217                RPCResult{
218                    RPCResult::Type::ARR, "", "",
219                    {
220                        {RPCResult::Type::OBJ, "", "",
221                        {
222                            {RPCResult::Type::STR, "address", "The receiving address"},
223                            {RPCResult::Type::STR_AMOUNT, "amount", "The total amount in " + CURRENCY_UNIT + " received by the address"},
224                            {RPCResult::Type::NUM, "confirmations", "The number of confirmations of the most recent transaction included"},
225                            {RPCResult::Type::STR, "label", "The label of the receiving address. The default label is \"\""},
226                            {RPCResult::Type::ARR, "txids", "",
227                            {
228                                {RPCResult::Type::STR_HEX, "txid", "The ids of transactions received with the address"},
229                            }},
230                        }},
231                    }
232                },
233                RPCExamples{
234                    HelpExampleCli("listreceivedbyaddress", "")
235            + HelpExampleCli("listreceivedbyaddress", "6 true")
236            + HelpExampleCli("listreceivedbyaddress", "6 true true \"\" true")
237            + HelpExampleRpc("listreceivedbyaddress", "6, true, true")
238            + HelpExampleRpc("listreceivedbyaddress", "6, true, true, \"" + EXAMPLE_ADDRESS[0] + "\", true")
239                },
240        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
241{
242    const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
243    if (!pwallet) return UniValue::VNULL;
244
245    // Make sure the results are valid at least up to the most recent block
246    // the user could have gotten from another RPC command prior to now
247    pwallet->BlockUntilSyncedToCurrentChain();
248
249    const bool include_immature_coinbase{request.params[4].isNull() ? false : request.params[4].get_bool()};
250