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