Querying and submitting pending transactions

1501                case PackageValidationResult::PCKG_POLICY:
1502                case PackageValidationResult::PCKG_TX:
1503                {
1504                    // Package-wide error we want to return, but we also want to return individual responses
1505                    package_msg = package_result.m_state.ToString();
1506                    CHECK_NONFATAL(package_result.m_tx_results.size() == txns.size() ||
1507                            package_result.m_tx_results.empty());
1508                    break;
1509                }
1510            }
1511
1512            size_t num_broadcast{0};
1513            for (const auto& tx : txns) {
1514                // We don't want to re-submit the txn for validation in BroadcastTransaction
1515                if (!mempool.exists(tx->GetHash())) {
1516                    continue;
1517                }
1518
1519                // We do not expect an error here; we are only broadcasting things already/still in mempool
1520                std::string err_string;
1521                const auto err = BroadcastTransaction(node,
1522                                                      tx,
1523                                                      err_string,
1524                                                      /*max_tx_fee=*/0,
1525                                                      node::TxBroadcast::MEMPOOL_AND_BROADCAST_TO_ALL,
1526                                                      /*wait_callback=*/true);
1527                if (err != TransactionError::OK) {
1528                    throw JSONRPCTransactionError(err,
1529                        strprintf("transaction broadcast failed: %s (%d transactions were broadcast successfully)",
1530                            err_string, num_broadcast));
1531                }
1532                num_broadcast++;
1533            }
1534
1535            UniValue rpc_result{UniValue::VOBJ};
1536            rpc_result.pushKV("package_msg", package_msg);
1537            UniValue tx_result_map{UniValue::VOBJ};
1538            std::set<Txid> replaced_txids;
1539            for (const auto& tx : txns) {
1540                UniValue result_inner{UniValue::VOBJ};
1541                result_inner.pushKV("txid", tx->GetHash().GetHex());
1542                const auto wtxid_hex = tx->GetWitnessHash().GetHex();
1543                auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
1544                if (it == package_result.m_tx_results.end()) {
1545                    // No per-tx result for this wtxid
1546                    // Current invariant: per-tx results are all-or-none (every member or empty on package abort).
1547                    // If any exist yet this one is missing, it's an unexpected partial map.
1548                    CHECK_NONFATAL(package_result.m_tx_results.empty());
1549                    result_inner.pushKV("error", "package-not-validated");
1550                    tx_result_map.pushKV(wtxid_hex, std::move(result_inner));
1551                    continue;
1552                }
1553                const auto& tx_result = it->second;
1554                switch(it->second.m_result_type) {
1555                case MempoolAcceptResult::ResultType::DIFFERENT_WITNESS:
1556                    result_inner.pushKV("other-wtxid", it->second.m_other_wtxid.value().GetHex());
1557                    break;
1558                case MempoolAcceptResult::ResultType::INVALID:
1559                    result_inner.pushKV("error", it->second.m_state.ToString());
1560                    break;
1561                case MempoolAcceptResult::ResultType::VALID:
1562                case MempoolAcceptResult::ResultType::MEMPOOL_ENTRY:
1563                    result_inner.pushKV("vsize_adjusted", it->second.m_vsize.value());
1564                    result_inner.pushKV("vsize", it->second.m_vsize.value());
1565                    result_inner.pushKV("vsize_bip141", GetVirtualTransactionSize(*tx));
1566                    UniValue fees(UniValue::VOBJ);
1567                    fees.pushKV("base", ValueFromAmount(it->second.m_base_fees.value()));
1568                    if (tx_result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
1569                        // Effective feerate is not provided for MEMPOOL_ENTRY transactions even
1570                        // though modified fees is known, because it is unknown whether package
1571                        // feerate was used when it was originally submitted.
1572                        fees.pushKV("effective-feerate", ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
1573                        UniValue effective_includes_res(UniValue::VARR);
1574                        for (const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
1575                            effective_includes_res.push_back(wtxid.ToString());
1576                        }
1577                        fees.pushKV("effective-includes", std::move(effective_includes_res));
1578                    }
1579                    result_inner.pushKV("fees", std::move(fees));
1580                    for (const auto& ptx : it->second.m_replaced_transactions) {
1581                        replaced_txids.insert(ptx->GetHash());
1582                    }
1583                    break;
1584                }
1585                tx_result_map.pushKV(wtxid_hex, std::move(result_inner));
1586            }
1587            rpc_result.pushKV("tx-results", std::move(tx_result_map));
1588            UniValue replaced_list(UniValue::VARR);
1589            for (const auto& txid : replaced_txids) replaced_list.push_back(txid.ToString());
1590            rpc_result.pushKV("replaced-transactions", std::move(replaced_list));
1591            return rpc_result;
1592        },
1593    };
1594}
1595
1596void RegisterMempoolRPCCommands(CRPCTable& t)
1597{
1598    static const CRPCCommand commands[]{
1599        {"rawtransactions", &sendrawtransaction},
1600        {"rawtransactions", &getprivatebroadcastinfo},
1601        {"rawtransactions", &abortprivatebroadcast},
1602        {"rawtransactions", &testmempoolaccept},
1603        {"blockchain", &getmempoolancestors},
1604        {"blockchain", &getmempooldescendants},
1605        {"blockchain", &getmempoolentry},
1606        {"blockchain", &getmempoolcluster},
1607        {"blockchain", &gettxspendingprevout},
1608        {"blockchain", &getmempoolinfo},
1609        {"hidden", &getmempoolfeeratediagram},
1610        {"blockchain", &getrawmempool},
1611        {"blockchain", &importmempool},
1612        {"blockchain", &savemempool},
1613        {"hidden", &getorphantxs},
1614        {"rawtransactions", &submitpackage},
1615    };
1616    for (const auto& c : commands) {
1617        t.appendCommand(c.name, &c);
1618    }
1619}
1620