Querying and submitting pending transactions

501        RPCResult{RPCResult::Type::NUM, "descendantsize", "virtual transaction size of in-mempool descendants (including this one)"},
502        RPCResult{RPCResult::Type::NUM, "ancestorcount", "number of in-mempool ancestor transactions (including this one)"},
503        RPCResult{RPCResult::Type::NUM, "ancestorsize", "virtual transaction size of in-mempool ancestors (including this one)"},
504        RPCResult{RPCResult::Type::NUM, "chunkweight", "sigops-adjusted weight (as defined in BIP 141 and modified by '-bytespersigop') of this transaction's chunk"},
505        RPCResult{RPCResult::Type::STR_HEX, "wtxid", "hash of serialized transaction, including witness data"},
506        RPCResult{RPCResult::Type::OBJ, "fees", "",
507            {
508                RPCResult{RPCResult::Type::STR_AMOUNT, "base", "transaction fee, denominated in " + CURRENCY_UNIT},
509                RPCResult{RPCResult::Type::STR_AMOUNT, "modified", "transaction fee with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},
510                RPCResult{RPCResult::Type::STR_AMOUNT, "ancestor", "transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},
511                RPCResult{RPCResult::Type::STR_AMOUNT, "descendant", "transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},
512                RPCResult{RPCResult::Type::STR_AMOUNT, "chunk", "transaction fees of chunk, denominated in " + CURRENCY_UNIT},
513            }},
514        RPCResult{RPCResult::Type::ARR, "depends", "unconfirmed transactions used as inputs for this transaction",
515            {RPCResult{RPCResult::Type::STR_HEX, "transactionid", "parent transaction id"}}},
516        RPCResult{RPCResult::Type::ARR, "spentby", "unconfirmed transactions spending outputs from this transaction",
517            {RPCResult{RPCResult::Type::STR_HEX, "transactionid", "child transaction id"}}},
518        RPCResult{RPCResult::Type::BOOL, "unbroadcast", "Whether this transaction is currently unbroadcast (initial broadcast not yet acknowledged by any peers)"},
519    };
520    if (IsDeprecatedRPCEnabled("bip125")) {
521        list.emplace_back(RPCResult::Type::BOOL, "bip125-replaceable", "Whether this transaction signals BIP125 replaceability or has an unconfirmed ancestor signaling BIP125 replaceability. (DEPRECATED)\n");
522    }
523    return list;
524}
525
526void AppendChunkInfo(UniValue& all_chunks, FeePerWeight chunk_feerate, std::vector<const CTxMemPoolEntry *> chunk_txs)
527{
528    UniValue chunk(UniValue::VOBJ);
529    chunk.pushKV("chunkfee", ValueFromAmount(chunk_feerate.fee));
530    chunk.pushKV("chunkweight", chunk_feerate.size);
531    UniValue chunk_txids(UniValue::VARR);
532    for (const auto& chunk_tx : chunk_txs) {
533        chunk_txids.push_back(chunk_tx->GetTx().GetHash().ToString());
534    }
535    chunk.pushKV("txs", std::move(chunk_txids));
536    all_chunks.push_back(std::move(chunk));
537}
538
539static void clusterToJSON(const CTxMemPool& pool, UniValue& info, std::vector<const CTxMemPoolEntry *> cluster) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)
540{
541    AssertLockHeld(pool.cs);
542    int total_weight{0};
543    for (const auto& tx : cluster) {
544        total_weight += tx->GetAdjustedWeight();
545    }
546    info.pushKV("clusterweight", total_weight);
547    info.pushKV("txcount", cluster.size());
548
549    // Output the cluster by chunk. This isn't handed to us by the mempool, but
550    // we can calculate it by looking at the chunk feerates of each transaction
551    // in the cluster.
552    FeePerWeight current_chunk_feerate = pool.GetMainChunkFeerate(*cluster[0]);
553    std::vector<const CTxMemPoolEntry *> current_chunk;
554    current_chunk.reserve(cluster.size());
555
556    UniValue all_chunks(UniValue::VARR);
557    for (const auto& tx : cluster) {
558        if (current_chunk_feerate.size == 0) {
559            // We've iterated all the transactions in the previous chunk; so
560            // append it to the output.
561            AppendChunkInfo(all_chunks, pool.GetMainChunkFeerate(*current_chunk[0]), current_chunk);
562            current_chunk.clear();
563            current_chunk_feerate = pool.GetMainChunkFeerate(*tx);
564        }
565        current_chunk.push_back(tx);
566        current_chunk_feerate.size -= tx->GetAdjustedWeight();
567    }
568    AppendChunkInfo(all_chunks, pool.GetMainChunkFeerate(*current_chunk[0]), current_chunk);
569    current_chunk.clear();
570    info.pushKV("chunks", std::move(all_chunks));
571}
572
573static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPoolEntry& e) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)
574{
575    AssertLockHeld(pool.cs);
576
577    auto [ancestor_count, ancestor_size, ancestor_fees] = pool.CalculateAncestorData(e);
578    auto [descendant_count, descendant_size, descendant_fees] = pool.CalculateDescendantData(e);
579
580    info.pushKV("vsize_adjusted", e.GetTxSize());
581    info.pushKV("vsize", e.GetTxSize());
582    info.pushKV("vsize_bip141", GetVirtualTransactionSize(e.GetTx()));
583    info.pushKV("weight", e.GetTxWeight());
584    info.pushKV("time", count_seconds(e.GetTime()));
585    info.pushKV("height", e.GetHeight());
586    info.pushKV("descendantcount", descendant_count);
587    info.pushKV("descendantsize", descendant_size);
588    info.pushKV("ancestorcount", ancestor_count);
589    info.pushKV("ancestorsize", ancestor_size);
590    info.pushKV("wtxid", e.GetTx().GetWitnessHash().ToString());
591    auto feerate = pool.GetMainChunkFeerate(e);
592    info.pushKV("chunkweight", feerate.size);
593
594    UniValue fees(UniValue::VOBJ);
595    fees.pushKV("base", ValueFromAmount(e.GetFee()));
596    fees.pushKV("modified", ValueFromAmount(e.GetModifiedFee()));
597    fees.pushKV("ancestor", ValueFromAmount(ancestor_fees));
598    fees.pushKV("descendant", ValueFromAmount(descendant_fees));
599    fees.pushKV("chunk", ValueFromAmount(feerate.fee));
600    info.pushKV("fees", std::move(fees));
601
602    const CTransaction& tx = e.GetTx();
603    std::set<std::string> setDepends;
604    for (const CTxIn& txin : tx.vin)
605    {
606        if (pool.exists(txin.prevout.hash))
607            setDepends.insert(txin.prevout.hash.ToString());
608    }
609
610    UniValue depends(UniValue::VARR);
611    for (const std::string& dep : setDepends)
612    {
613        depends.push_back(dep);
614    }
615
616    info.pushKV("depends", std::move(depends));
617
618    UniValue spent(UniValue::VARR);
619    for (const CTxMemPoolEntry& child : pool.GetChildren(e)) {
620        spent.push_back(child.GetTx().GetHash().ToString());
621    }
622
623    info.pushKV("spentby", std::move(spent));
624    info.pushKV("unbroadcast", pool.IsUnbroadcastTx(tx.GetHash()));
625
626    // Add opt-in RBF status
627    if (IsDeprecatedRPCEnabled("bip125")) {
628        bool rbfStatus = false;
629        RBFTransactionState rbfState = IsRBFOptIn(tx, pool);
630        if (rbfState == RBFTransactionState::UNKNOWN) {
631            throw JSONRPCError(RPC_MISC_ERROR, "Transaction is not in mempool");
632        } else if (rbfState == RBFTransactionState::REPLACEABLE_BIP125) {
633            rbfStatus = true;
634        }
635        info.pushKV("bip125-replaceable", rbfStatus);
636    }
637}
638
639UniValue MempoolToJSON(const CTxMemPool& pool, bool verbose, bool include_mempool_sequence)
640{
641    if (verbose) {
642        if (include_mempool_sequence) {
643            throw JSONRPCError(RPC_INVALID_PARAMETER, "Verbose results cannot contain mempool sequence values.");
644        }
645        LOCK(pool.cs);
646        UniValue o(UniValue::VOBJ);
647        for (const CTxMemPoolEntry& e : pool.entryAll()) {
648            UniValue info(UniValue::VOBJ);
649            entryToJSON(pool, info, e);
650            // Mempool has unique entries so there is no advantage in using
651            // UniValue::pushKV, which checks if the key already exists in O(N).
652            // UniValue::pushKVEnd is used instead which currently is O(1).
653            o.pushKVEnd(e.GetTx().GetHash().ToString(), std::move(info));
654        }
655        return o;
656    } else {
657        UniValue a(UniValue::VARR);
658        uint64_t mempool_sequence;
659        {
660            LOCK(pool.cs);
661            for (const CTxMemPoolEntry& e : pool.entryAll()) {
662                a.push_back(e.GetTx().GetHash().ToString());
663            }
664            mempool_sequence = pool.GetSequence();
665        }
666        if (!include_mempool_sequence) {
667            return a;
668        } else {
669            UniValue o(UniValue::VOBJ);
670            o.pushKV("txids", std::move(a));
671            o.pushKV("mempool_sequence", mempool_sequence);
672            return o;
673        }
674    }
675}
676
677static RPCMethod getmempoolfeeratediagram()
678{
679    return RPCMethod{"getmempoolfeeratediagram",
680        "Returns the feerate diagram for the whole mempool.",
681        {},
682        {
683            RPCResult{"mempool chunks",
684                RPCResult::Type::ARR, "", "",
685                {
686                    {
687                        RPCResult::Type::OBJ, "", "",
688                        {
689                            {RPCResult::Type::NUM, "weight", "cumulative sigops-adjusted weight"},
690                            {RPCResult::Type::STR_AMOUNT, "fee", "cumulative fee"}
691                        }
692                    }
693                }
694            }
695        },
696        RPCExamples{
697            HelpExampleCli("getmempoolfeeratediagram", "")
698            + HelpExampleRpc("getmempoolfeeratediagram", "")
699        },
700        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
701        {
702            const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
703            LOCK(mempool.cs);
704
705            UniValue result(UniValue::VARR);
706
707            auto diagram = mempool.GetFeerateDiagram();
708
709            for (auto f : diagram) {
710                UniValue o(UniValue::VOBJ);
711                o.pushKV("weight", f.size);
712                o.pushKV("fee", ValueFromAmount(f.fee));
713                result.push_back(o);
714            }
715            return result;
716        }
717    };
718}
719
720static RPCMethod getrawmempool()
721{
722    return RPCMethod{
723        "getrawmempool",
724        "Returns all transaction ids in memory pool as a json array of string transaction ids.\n"
725        "\nHint: use getmempoolentry to fetch a specific transaction from the mempool.\n",
726        {
727            {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
728            {"mempool_sequence", RPCArg::Type::BOOL, RPCArg::Default{false}, "If verbose=false, returns a json object with transaction list and mempool sequence number attached."},
729        },
730        {
731            RPCResult{"for verbose = false",
732                RPCResult::Type::ARR, "", "",
733                {
734                    {RPCResult::Type::STR_HEX, "", "The transaction id"},
735                }},
736            RPCResult{"for verbose = true",
737                RPCResult::Type::OBJ_DYN, "", "",
738                {
739                    {RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},
740                }},
741            RPCResult{"for verbose = false and mempool_sequence = true",
742                RPCResult::Type::OBJ, "", "",
743                {
744                    {RPCResult::Type::ARR, "txids", "",
745                    {
746                        {RPCResult::Type::STR_HEX, "", "The transaction id"},
747                    }},
748                    {RPCResult::Type::NUM, "mempool_sequence", "The mempool sequence value."},
749                }},
750        },