1// Copyright (c) 2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <rpc/register.h> // IWYU pragma: associated
7
8#include <chain.h>
9#include <coins.h>
10#include <crypto/hex_base.h>
11#include <index/txindex.h>
12#include <merkleblock.h>
13#include <node/blockstorage.h>
14#include <node/transaction.h>
15#include <primitives/block.h>
16#include <primitives/transaction.h>
17#include <rpc/blockchain.h>
18#include <rpc/protocol.h>
19#include <rpc/request.h>
20#include <rpc/server.h>
21#include <rpc/server_util.h>
22#include <rpc/util.h>
23#include <streams.h>
24#include <sync.h>
25#include <uint256.h>
26#include <univalue.h>
27#include <validation.h>
28
29#include <memory>
30#include <set>
31#include <span>
32#include <string>
33#include <utility>
34#include <vector>
35
36using node::GetTransaction;
37
38static RPCMethod gettxoutproof()
39{
40    return RPCMethod{
41        "gettxoutproof",
42        "Returns a hex-encoded proof that \"txid\" was included in a block.\n"
43        "\nNOTE: By default this function only works sometimes. This is when there is an\n"
44        "unspent output in the utxo for this transaction. To make it always work,\n"
45        "you need to maintain a transaction index, using the -txindex command line option or\n"
46        "specify the block in which the transaction is included manually (by blockhash).\n",
47        {
48            {"txids", RPCArg::Type::ARR, RPCArg::Optional::NO, "The txids to filter",
49                {
50                    {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "A transaction hash"},
51                },
52            },
53            {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "If specified, looks for txid in the block with this hash"},
54        },
55        RPCResult{
56            RPCResult::Type::STR, "data", "A string that is a serialized, hex-encoded data for the proof."
57        },
58        RPCExamples{""},
59        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
60        {
61            std::set<Txid> setTxids;
62            UniValue txids = request.params[0].get_array();
63            if (txids.empty()) {
64                throw JSONRPCError(RPC_INVALID_PARAMETER, "Parameter 'txids' cannot be empty");
65            }
66            for (unsigned int idx = 0; idx < txids.size(); idx++) {
67                auto ret{setTxids.insert(Txid::FromUint256(ParseHashV(txids[idx], "txid")))};
68                if (!ret.second) {
69                    throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated txid: ") + txids[idx].get_str());
70                }
71            }
72
73            const CBlockIndex* pblockindex = nullptr;
74            uint256 hashBlock;
75            ChainstateManager& chainman = EnsureAnyChainman(request.context);
76            if (!request.params[1].isNull()) {
77                LOCK(cs_main);
78                hashBlock = ParseHashV(request.params[1], "blockhash");
79                pblockindex = chainman.m_blockman.LookupBlockIndex(hashBlock);
80                if (!pblockindex) {
81                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
82                }
83            } else {
84                LOCK(cs_main);
85                Chainstate& active_chainstate = chainman.ActiveChainstate();
86
87                // Loop through txids and try to find which block they're in. Exit loop once a block is found.
88                for (const auto& tx : setTxids) {
89                    const Coin& coin{AccessByTxid(active_chainstate.CoinsTip(), tx)};
90                    if (!coin.IsSpent()) {
91                        pblockindex = active_chainstate.m_chain[coin.nHeight];
92                        break;
93                    }
94                }
95            }
96
97
98            // Allow txindex to catch up if we need to query it and before we acquire cs_main.
99            if (g_txindex && !pblockindex) {
100                g_txindex->BlockUntilSyncedToCurrentChain();
101            }
102
103            if (pblockindex == nullptr) {
104                const CTransactionRef tx = GetTransaction(/*block_index=*/nullptr, /*mempool=*/nullptr, *setTxids.begin(), chainman.m_blockman, hashBlock);
105                if (!tx || hashBlock.IsNull()) {
106                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not yet in block");
107                }
108
109                LOCK(cs_main);
110                pblockindex = chainman.m_blockman.LookupBlockIndex(hashBlock);
111                if (!pblockindex) {
112                    throw JSONRPCError(RPC_INTERNAL_ERROR, "Transaction index corrupt");
113                }
114            }
115
116            {
117                LOCK(cs_main);
118                CheckBlockDataAvailability(chainman.m_blockman, *pblockindex, /*check_for_undo=*/false);
119            }
120            CBlock block;
121            if (!chainman.m_blockman.ReadBlock(block, *pblockindex)) {
122                throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");
123            }
124
125            unsigned int ntxFound = 0;
126            for (const auto& tx : block.vtx) {
127                if (setTxids.contains(tx->GetHash())) {
128                    ntxFound++;
129                }
130            }
131            if (ntxFound != setTxids.size()) {
132                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Not all transactions found in specified or retrieved block");
133            }
134
135            DataStream ssMB{};
136            CMerkleBlock mb(block, setTxids);
137            ssMB << mb;
138            std::string strHex = HexStr(ssMB);
139            return strHex;
140        },
141    };
142}
143
144static RPCMethod verifytxoutproof()
145{
146    return RPCMethod{
147        "verifytxoutproof",
148        "Verifies that a proof points to a transaction in a block, returning the transaction it commits to\n"
149        "and throwing an RPC error if the block is not in our best chain\n",
150        {
151            {"proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex-encoded proof generated by gettxoutproof"},
152        },
153        RPCResult{
154            RPCResult::Type::ARR, "", "",
155            {
156                {RPCResult::Type::STR_HEX, "txid", "The txid(s) which the proof commits to, or empty array if the proof cannot be validated."},
157            }
158        },
159        RPCExamples{""},
160        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
161        {
162            CMerkleBlock merkleBlock;
163            SpanReader{ParseHexV(request.params[0], "proof")} >> merkleBlock;
164
165            UniValue res(UniValue::VARR);
166
167            std::vector<Txid> vMatch;
168            std::vector<unsigned int> vIndex;
169            if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) != merkleBlock.header.hashMerkleRoot)
170                return res;
171
172            ChainstateManager& chainman = EnsureAnyChainman(request.context);
173            LOCK(cs_main);
174
175            const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(merkleBlock.header.GetHash());
176            if (!pindex || !chainman.ActiveChain().Contains(*pindex) || pindex->nTx == 0) {
177                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found in chain");
178            }
179
180            // Check if proof is valid, only add results if so
181            if (pindex->nTx == merkleBlock.txn.GetNumTransactions()) {
182                for (const auto& txid : vMatch) {
183                    res.push_back(txid.GetHex());
184                }
185            }
186
187            return res;
188        },
189    };
190}
191
192void RegisterTxoutProofRPCCommands(CRPCTable& t)
193{
194    static const CRPCCommand commands[]{
195        {"blockchain", &gettxoutproof},
196        {"blockchain", &verifytxoutproof},
197    };
198    for (const auto& c : commands) {
199        t.appendCommand(c.name, &c);
200    }
201}
202