Blockchain information through RPC

251    result.pushKV("coinbase_tx", coinbaseTxToJSON(*block.vtx[0]));
252
253    UniValue txs(UniValue::VARR);
254    txs.reserve(block.vtx.size());
255
256    switch (verbosity) {
257        case TxVerbosity::SHOW_TXID:
258            for (const CTransactionRef& tx : block.vtx) {
259                txs.push_back(tx->GetHash().GetHex());
260            }
261            break;
262
263        case TxVerbosity::SHOW_DETAILS:
264        case TxVerbosity::SHOW_DETAILS_AND_PREVOUT:
265            CBlockUndo blockUndo;
266            const bool is_not_pruned{WITH_LOCK(::cs_main, return !blockman.IsBlockPruned(blockindex))};
267            bool have_undo{is_not_pruned && WITH_LOCK(::cs_main, return blockindex.nStatus & BLOCK_HAVE_UNDO)};
268            if (have_undo && !blockman.ReadBlockUndo(blockUndo, blockindex)) {
269                throw JSONRPCError(RPC_INTERNAL_ERROR, "Undo data expected but can't be read. This could be due to disk corruption or a conflict with a pruning event.");
270            }
271            for (size_t i = 0; i < block.vtx.size(); ++i) {
272                const CTransactionRef& tx = block.vtx.at(i);
273                // coinbase transaction (i.e. i == 0) doesn't have undo data
274                const CTxUndo* txundo = (have_undo && i > 0) ? &blockUndo.vtxundo.at(i - 1) : nullptr;
275                UniValue objTx(UniValue::VOBJ);
276                TxToUniv(*tx, /*block_hash=*/uint256(), /*entry=*/objTx, /*include_hex=*/true, txundo, verbosity);
277                txs.push_back(std::move(objTx));
278            }
279            break;
280    }
281
282    result.pushKV("tx", std::move(txs));
283
284    return result;
285}
286
287static RPCMethod getblockcount()
288{
289    return RPCMethod{
290        "getblockcount",
291        "Returns the height of the most-work fully-validated chain.\n"
292                "The genesis block has height 0.\n",
293                {},
294                RPCResult{
295                    RPCResult::Type::NUM, "", "The current block count"},
296                RPCExamples{
297                    HelpExampleCli("getblockcount", "")
298            + HelpExampleRpc("getblockcount", "")
299                },
300        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
301{
302    ChainstateManager& chainman = EnsureAnyChainman(request.context);
303    LOCK(cs_main);
304    return chainman.ActiveChain().Height();
305},
306    };
307}
308
309static RPCMethod getbestblockhash()
310{
311    return RPCMethod{
312        "getbestblockhash",
313        "Returns the hash of the best (tip) block in the most-work fully-validated chain.\n",
314                {},
315                RPCResult{
316                    RPCResult::Type::STR_HEX, "", "the block hash, hex-encoded"},
317                RPCExamples{
318                    HelpExampleCli("getbestblockhash", "")
319            + HelpExampleRpc("getbestblockhash", "")
320                },
321        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
322{
323    ChainstateManager& chainman = EnsureAnyChainman(request.context);
324    LOCK(cs_main);
325    return chainman.ActiveChain().Tip()->GetBlockHash().GetHex();
326},
327    };
328}
329
330static RPCMethod waitfornewblock()
331{
332    return RPCMethod{
333        "waitfornewblock",
334        "Waits for any new block and returns useful info about it.\n"
335                "\nReturns the current block on timeout or exit.\n"
336                "\nMake sure to use no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",
337                {
338                    {"timeout", RPCArg::Type::NUM, RPCArg::Default{0}, "Time in milliseconds to wait for a response. 0 indicates no timeout."},
339                    {"current_tip", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "Method waits for the chain tip to differ from this."},
340                },
341                RPCResult{
342                    RPCResult::Type::OBJ, "", "",
343                    {
344                        {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
345                        {RPCResult::Type::NUM, "height", "Block height"},
346                    }},
347                RPCExamples{
348                    HelpExampleCli("waitfornewblock", "1000")
349            + HelpExampleRpc("waitfornewblock", "1000")
350                },
351        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
352{
353    int timeout = 0;
354    if (!request.params[0].isNull())
355        timeout = request.params[0].getInt<int>();
356    if (timeout < 0) throw JSONRPCError(RPC_MISC_ERROR, "Negative timeout");
357
358    NodeContext& node = EnsureAnyNodeContext(request.context);
359    Mining& miner = EnsureMining(node);
360
361    // If the caller provided a current_tip value, pass it to waitTipChanged().
362    //
363    // If the caller did not provide a current tip hash, call getTip() to get
364    // one and wait for the tip to be different from this value. This mode is
365    // less reliable because if the tip changed between waitfornewblock calls,
366    // it will need to change a second time before this call returns.
367    BlockRef current_block{CHECK_NONFATAL(miner.getTip()).value()};
368
369    uint256 tip_hash{request.params[1].isNull()
370        ? current_block.hash
371        : ParseHashV(request.params[1], "current_tip")};
372
373    // If the user provided an invalid current_tip then this call immediately
374    // returns the current tip.
375    std::optional<BlockRef> block = timeout ? miner.waitTipChanged(tip_hash, std::chrono::milliseconds(timeout)) :
376                                              miner.waitTipChanged(tip_hash);
377
378    // Return current block upon shutdown
379    if (block) current_block = *block;
380
381    UniValue ret(UniValue::VOBJ);
382    ret.pushKV("hash", current_block.hash.GetHex());
383    ret.pushKV("height", current_block.height);
384    return ret;
385},
386    };
387}
388
389static RPCMethod waitforblock()
390{
391    return RPCMethod{
392        "waitforblock",
393        "Waits for a specific new block and returns useful info about it.\n"
394                "\nReturns the current block on timeout or exit.\n"
395                "\nMake sure to use no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",
396                {
397                    {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Block hash to wait for."},
398                    {"timeout", RPCArg::Type::NUM, RPCArg::Default{0}, "Time in milliseconds to wait for a response. 0 indicates no timeout."},
399                },
400                RPCResult{
401                    RPCResult::Type::OBJ, "", "",
402                    {
403                        {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
404                        {RPCResult::Type::NUM, "height", "Block height"},
405                    }},
406                RPCExamples{
407                    HelpExampleCli("waitforblock", "\"0000000000079f8ef3d2c688c244eb7a4570b24c9ed7b4a8c619eb02596f8862\" 1000")
408            + HelpExampleRpc("waitforblock", "\"0000000000079f8ef3d2c688c244eb7a4570b24c9ed7b4a8c619eb02596f8862\", 1000")
409                },
410        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
411{
412    int timeout = 0;
413
414    uint256 hash(ParseHashV(request.params[0], "blockhash"));
415
416    if (!request.params[1].isNull())
417        timeout = request.params[1].getInt<int>();
418    if (timeout < 0) throw JSONRPCError(RPC_MISC_ERROR, "Negative timeout");
419
420    NodeContext& node = EnsureAnyNodeContext(request.context);
421    Mining& miner = EnsureMining(node);
422
423    // Abort if RPC came out of warmup too early
424    BlockRef current_block{CHECK_NONFATAL(miner.getTip()).value()};
425
426    const auto deadline{std::chrono::steady_clock::now() + 1ms * timeout};
427    while (current_block.hash != hash) {
428        std::optional<BlockRef> block;
429        if (timeout) {
430            auto now{std::chrono::steady_clock::now()};
431            if (now >= deadline) break;
432            const MillisecondsDouble remaining{deadline - now};
433            block = miner.waitTipChanged(current_block.hash, remaining);
434        } else {
435            block = miner.waitTipChanged(current_block.hash);
436        }
437        // Return current block upon shutdown
438        if (!block) break;
439        current_block = *block;
440    }
441
442    UniValue ret(UniValue::VOBJ);
443    ret.pushKV("hash", current_block.hash.GetHex());
444    ret.pushKV("height", current_block.height);
445    return ret;
446},
447    };
448}
449
450static RPCMethod waitforblockheight()
451{
452    return RPCMethod{
453        "waitforblockheight",
454        "Waits for (at least) block height and returns the height and hash\n"
455                "of the current tip.\n"
456                "\nReturns the current block on timeout or exit.\n"
457                "\nMake sure to use no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",
458                {
459                    {"height", RPCArg::Type::NUM, RPCArg::Optional::NO, "Block height to wait for."},
460                    {"timeout", RPCArg::Type::NUM, RPCArg::Default{0}, "Time in milliseconds to wait for a response. 0 indicates no timeout."},
461                },
462                RPCResult{
463                    RPCResult::Type::OBJ, "", "",
464                    {
465                        {RPCResult::Type::STR_HEX, "hash", "The blockhash"},
466                        {RPCResult::Type::NUM, "height", "Block height"},
467                    }},
468                RPCExamples{
469                    HelpExampleCli("waitforblockheight", "100 1000")
470            + HelpExampleRpc("waitforblockheight", "100, 1000")
471                },
472        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
473{
474    int timeout = 0;
475
476    int height = request.params[0].getInt<int>();
477
478    if (!request.params[1].isNull())
479        timeout = request.params[1].getInt<int>();
480    if (timeout < 0) throw JSONRPCError(RPC_MISC_ERROR, "Negative timeout");
481
482    NodeContext& node = EnsureAnyNodeContext(request.context);
483    Mining& miner = EnsureMining(node);
484
485    // Abort if RPC came out of warmup too early
486    BlockRef current_block{CHECK_NONFATAL(miner.getTip()).value()};
487
488    const auto deadline{std::chrono::steady_clock::now() + 1ms * timeout};
489
490    while (current_block.height < height) {
491        std::optional<BlockRef> block;
492        if (timeout) {
493            auto now{std::chrono::steady_clock::now()};
494            if (now >= deadline) break;
495            const MillisecondsDouble remaining{deadline - now};
496            block = miner.waitTipChanged(current_block.hash, remaining);
497        } else {
498            block = miner.waitTipChanged(current_block.hash);
499        }
500        // Return current block on shutdown