phantom/bitcoin
1
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-01-10 03:47:29 -03:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

rpc: avoid copying into UniValue

Browse source 
These are simple (and hopefully obviously correct) copies that can be moves
instead.
This commit is contained in:
Cory Fields 2024-05-13 20:20:10 +00:00
parent ecd23656db
commit d7707d9843
27 changed files with 183 additions and 183 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/bitcoin-cli.cpp
View file

@ -297,7 +297,7 @@ public:
total += counts.at(i); total += counts.at(i);
} }
addresses.pushKV("total", total); addresses.pushKV("total", total);
result.pushKV("addresses_known", addresses); result.pushKV("addresses_known", std::move(addresses));
return JSONRPCReplyObj(std::move(result), NullUniValue, /*id=*/1, JSONRPCVersion::V1_LEGACY); return JSONRPCReplyObj(std::move(result), NullUniValue, /*id=*/1, JSONRPCVersion::V1_LEGACY);
} }
}; };
@ -348,7 +348,7 @@ public:
connections.pushKV("in", batch[ID_NETWORKINFO]["result"]["connections_in"]); connections.pushKV("in", batch[ID_NETWORKINFO]["result"]["connections_in"]);
connections.pushKV("out", batch[ID_NETWORKINFO]["result"]["connections_out"]); connections.pushKV("out", batch[ID_NETWORKINFO]["result"]["connections_out"]);
connections.pushKV("total", batch[ID_NETWORKINFO]["result"]["connections"]); connections.pushKV("total", batch[ID_NETWORKINFO]["result"]["connections"]);
result.pushKV("connections", connections); result.pushKV("connections", std::move(connections));
result.pushKV("networks", batch[ID_NETWORKINFO]["result"]["networks"]); result.pushKV("networks", batch[ID_NETWORKINFO]["result"]["networks"]);
result.pushKV("difficulty", batch[ID_BLOCKCHAININFO]["result"]["difficulty"]); result.pushKV("difficulty", batch[ID_BLOCKCHAININFO]["result"]["difficulty"]);
@ -940,7 +940,7 @@ static void GetWalletBalances(UniValue& result)
const UniValue& balance = getbalances.find_value("result")["mine"]["trusted"]; const UniValue& balance = getbalances.find_value("result")["mine"]["trusted"];
balances.pushKV(wallet_name, balance); balances.pushKV(wallet_name, balance);
} }
result.pushKV("balances", balances); result.pushKV("balances", std::move(balances));
} }
/** /**

18
src/core_write.cpp
View file

@ -201,14 +201,14 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
UniValue o(UniValue::VOBJ); UniValue o(UniValue::VOBJ);
o.pushKV("asm", ScriptToAsmStr(txin.scriptSig, true)); o.pushKV("asm", ScriptToAsmStr(txin.scriptSig, true));
o.pushKV("hex", HexStr(txin.scriptSig)); o.pushKV("hex", HexStr(txin.scriptSig));
in.pushKV("scriptSig", o); in.pushKV("scriptSig", std::move(o));
} }
if (!tx.vin[i].scriptWitness.IsNull()) { if (!tx.vin[i].scriptWitness.IsNull()) {
UniValue txinwitness(UniValue::VARR); UniValue txinwitness(UniValue::VARR);
for (const auto& item : tx.vin[i].scriptWitness.stack) { for (const auto& item : tx.vin[i].scriptWitness.stack) {
txinwitness.push_back(HexStr(item)); txinwitness.push_back(HexStr(item));
} }
in.pushKV("txinwitness", txinwitness); in.pushKV("txinwitness", std::move(txinwitness));
} }
if (have_undo) { if (have_undo) {
const Coin& prev_coin = txundo->vprevout[i]; const Coin& prev_coin = txundo->vprevout[i];
@ -224,14 +224,14 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
p.pushKV("generated", bool(prev_coin.fCoinBase)); p.pushKV("generated", bool(prev_coin.fCoinBase));
p.pushKV("height", uint64_t(prev_coin.nHeight)); p.pushKV("height", uint64_t(prev_coin.nHeight));
p.pushKV("value", ValueFromAmount(prev_txout.nValue)); p.pushKV("value", ValueFromAmount(prev_txout.nValue));
p.pushKV("scriptPubKey", o_script_pub_key); p.pushKV("scriptPubKey", std::move(o_script_pub_key));
in.pushKV("prevout", p); in.pushKV("prevout", std::move(p));
} }
} }
in.pushKV("sequence", (int64_t)txin.nSequence); in.pushKV("sequence", (int64_t)txin.nSequence);
vin.push_back(in); vin.push_back(std::move(in));
} }
entry.pushKV("vin", vin); entry.pushKV("vin", std::move(vin));
UniValue vout(UniValue::VARR); UniValue vout(UniValue::VARR);
for (unsigned int i = 0; i < tx.vout.size(); i++) { for (unsigned int i = 0; i < tx.vout.size(); i++) {
@ -244,14 +244,14 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
UniValue o(UniValue::VOBJ); UniValue o(UniValue::VOBJ);
ScriptToUniv(txout.scriptPubKey, /*out=*/o, /*include_hex=*/true, /*include_address=*/true); ScriptToUniv(txout.scriptPubKey, /*out=*/o, /*include_hex=*/true, /*include_address=*/true);
out.pushKV("scriptPubKey", o); out.pushKV("scriptPubKey", std::move(o));
vout.push_back(out); vout.push_back(std::move(out));
if (have_undo) { if (have_undo) {
amt_total_out += txout.nValue; amt_total_out += txout.nValue;
} }
} }
entry.pushKV("vout", vout); entry.pushKV("vout", std::move(vout));
if (have_undo) { if (have_undo) {
const CAmount fee = amt_total_in - amt_total_out; const CAmount fee = amt_total_in - amt_total_out;

2
src/net_types.cpp
View file

@ -43,7 +43,7 @@ UniValue BanMapToJson(const banmap_t& bans)
const auto& ban_entry = it.second; const auto& ban_entry = it.second;
UniValue j = ban_entry.ToJson(); UniValue j = ban_entry.ToJson();
j.pushKV(BANMAN_JSON_ADDR_KEY, address.ToString()); j.pushKV(BANMAN_JSON_ADDR_KEY, address.ToString());
bans_json.push_back(j); bans_json.push_back(std::move(j));
} }
return bans_json; return bans_json;
} }

6
src/rest.cpp
View file

@ -934,10 +934,10 @@ static bool rest_getutxos(const std::any& context, HTTPRequest* req, const std::
// include the script in a json output // include the script in a json output
UniValue o(UniValue::VOBJ); UniValue o(UniValue::VOBJ);
ScriptToUniv(coin.out.scriptPubKey, /*out=*/o, /*include_hex=*/true, /*include_address=*/true); ScriptToUniv(coin.out.scriptPubKey, /*out=*/o, /*include_hex=*/true, /*include_address=*/true);
utxo.pushKV("scriptPubKey", o); utxo.pushKV("scriptPubKey", std::move(o));
utxos.push_back(utxo); utxos.push_back(std::move(utxo));
} }
objGetUTXOResponse.pushKV("utxos", utxos); objGetUTXOResponse.pushKV("utxos", std::move(utxos));
// return json string // return json string
std::string strJSON = objGetUTXOResponse.write() + "\n"; std::string strJSON = objGetUTXOResponse.write() + "\n";

24
src/rpc/blockchain.cpp
View file

@ -1025,9 +1025,9 @@ static RPCHelpMan gettxoutsetinfo()
unspendables.pushKV("bip30", ValueFromAmount(stats.total_unspendables_bip30 - prev_stats.total_unspendables_bip30)); unspendables.pushKV("bip30", ValueFromAmount(stats.total_unspendables_bip30 - prev_stats.total_unspendables_bip30));
unspendables.pushKV("scripts", ValueFromAmount(stats.total_unspendables_scripts - prev_stats.total_unspendables_scripts)); unspendables.pushKV("scripts", ValueFromAmount(stats.total_unspendables_scripts - prev_stats.total_unspendables_scripts));
unspendables.pushKV("unclaimed_rewards", ValueFromAmount(stats.total_unspendables_unclaimed_rewards - prev_stats.total_unspendables_unclaimed_rewards)); unspendables.pushKV("unclaimed_rewards", ValueFromAmount(stats.total_unspendables_unclaimed_rewards - prev_stats.total_unspendables_unclaimed_rewards));
block_info.pushKV("unspendables", unspendables); block_info.pushKV("unspendables", std::move(unspendables));
ret.pushKV("block_info", block_info); ret.pushKV("block_info", std::move(block_info));
} }
} else { } else {
throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to read UTXO set"); throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to read UTXO set");
@ -1111,7 +1111,7 @@ static RPCHelpMan gettxout()
ret.pushKV("value", ValueFromAmount(coin.out.nValue)); ret.pushKV("value", ValueFromAmount(coin.out.nValue));
UniValue o(UniValue::VOBJ); UniValue o(UniValue::VOBJ);
ScriptToUniv(coin.out.scriptPubKey, /*out=*/o, /*include_hex=*/true, /*include_address=*/true); ScriptToUniv(coin.out.scriptPubKey, /*out=*/o, /*include_hex=*/true, /*include_address=*/true);
ret.pushKV("scriptPubKey", o); ret.pushKV("scriptPubKey", std::move(o));
ret.pushKV("coinbase", (bool)coin.fCoinBase); ret.pushKV("coinbase", (bool)coin.fCoinBase);
return ret; return ret;
@ -1161,7 +1161,7 @@ static void SoftForkDescPushBack(const CBlockIndex* blockindex, UniValue& softfo
// one below the activation height // one below the activation height
rv.pushKV("active", DeploymentActiveAfter(blockindex, chainman, dep)); rv.pushKV("active", DeploymentActiveAfter(blockindex, chainman, dep));
rv.pushKV("height", chainman.GetConsensus().DeploymentHeight(dep)); rv.pushKV("height", chainman.GetConsensus().DeploymentHeight(dep));
softforks.pushKV(DeploymentName(dep), rv); softforks.pushKV(DeploymentName(dep), std::move(rv));
} }
static void SoftForkDescPushBack(const CBlockIndex* blockindex, UniValue& softforks, const ChainstateManager& chainman, Consensus::DeploymentPos id) static void SoftForkDescPushBack(const CBlockIndex* blockindex, UniValue& softforks, const ChainstateManager& chainman, Consensus::DeploymentPos id)
@ -1214,7 +1214,7 @@ static void SoftForkDescPushBack(const CBlockIndex* blockindex, UniValue& softfo
statsUV.pushKV("threshold", statsStruct.threshold); statsUV.pushKV("threshold", statsStruct.threshold);
statsUV.pushKV("possible", statsStruct.possible); statsUV.pushKV("possible", statsStruct.possible);
} }
bip9.pushKV("statistics", statsUV); bip9.pushKV("statistics", std::move(statsUV));
std::string sig; std::string sig;
sig.reserve(signals.size()); sig.reserve(signals.size());
@ -1230,9 +1230,9 @@ static void SoftForkDescPushBack(const CBlockIndex* blockindex, UniValue& softfo
rv.pushKV("height", chainman.m_versionbitscache.StateSinceHeight(blockindex, chainman.GetConsensus(), id)); rv.pushKV("height", chainman.m_versionbitscache.StateSinceHeight(blockindex, chainman.GetConsensus(), id));
} }
rv.pushKV("active", ThresholdState::ACTIVE == next_state); rv.pushKV("active", ThresholdState::ACTIVE == next_state);
rv.pushKV("bip9", bip9); rv.pushKV("bip9", std::move(bip9));
softforks.pushKV(DeploymentName(id), rv); softforks.pushKV(DeploymentName(id), std::move(rv));
} }
// used by rest.cpp:rest_chaininfo, so cannot be static // used by rest.cpp:rest_chaininfo, so cannot be static
@ -1498,7 +1498,7 @@ static RPCHelpMan getchaintips()
} }
obj.pushKV("status", status); obj.pushKV("status", status);
res.push_back(obj); res.push_back(std::move(obj));
} }
return res; return res;
@ -1978,7 +1978,7 @@ static RPCHelpMan getblockstats()
ret_all.pushKV("avgfeerate", total_weight ? (totalfee * WITNESS_SCALE_FACTOR) / total_weight : 0); // Unit: sat/vbyte ret_all.pushKV("avgfeerate", total_weight ? (totalfee * WITNESS_SCALE_FACTOR) / total_weight : 0); // Unit: sat/vbyte
ret_all.pushKV("avgtxsize", (block.vtx.size() > 1) ? total_size / (block.vtx.size() - 1) : 0); ret_all.pushKV("avgtxsize", (block.vtx.size() > 1) ? total_size / (block.vtx.size() - 1) : 0);
ret_all.pushKV("blockhash", pindex.GetBlockHash().GetHex()); ret_all.pushKV("blockhash", pindex.GetBlockHash().GetHex());
ret_all.pushKV("feerate_percentiles", feerates_res); ret_all.pushKV("feerate_percentiles", std::move(feerates_res));
ret_all.pushKV("height", (int64_t)pindex.nHeight); ret_all.pushKV("height", (int64_t)pindex.nHeight);
ret_all.pushKV("ins", inputs); ret_all.pushKV("ins", inputs);
ret_all.pushKV("maxfee", maxfee); ret_all.pushKV("maxfee", maxfee);
@ -2262,9 +2262,9 @@ static RPCHelpMan scantxoutset()
unspent.pushKV("coinbase", coin.IsCoinBase()); unspent.pushKV("coinbase", coin.IsCoinBase());
unspent.pushKV("height", (int32_t)coin.nHeight); unspent.pushKV("height", (int32_t)coin.nHeight);
unspents.push_back(unspent); unspents.push_back(std::move(unspent));
} }
result.pushKV("unspents", unspents); result.pushKV("unspents", std::move(unspents));
result.pushKV("total_amount", ValueFromAmount(total_in)); result.pushKV("total_amount", ValueFromAmount(total_in));
} else { } else {
throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid action '%s'", action)); throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid action '%s'", action));
@ -2504,7 +2504,7 @@ static RPCHelpMan scanblocks()
ret.pushKV("from_height", start_block_height); ret.pushKV("from_height", start_block_height);
ret.pushKV("to_height", start_index->nHeight); // start_index is always the last scanned block here ret.pushKV("to_height", start_index->nHeight); // start_index is always the last scanned block here
ret.pushKV("relevant_blocks", blocks); ret.pushKV("relevant_blocks", std::move(blocks));
ret.pushKV("completed", completed); ret.pushKV("completed", completed);
} }
else { else {

2
src/rpc/client.cpp
View file

@ -391,7 +391,7 @@ UniValue RPCConvertNamedValues(const std::string &strMethod, const std::vector<s
// Use pushKVEnd instead of pushKV to avoid overwriting an explicit // Use pushKVEnd instead of pushKV to avoid overwriting an explicit
// "args" value with an implicit one. Let the RPC server handle the // "args" value with an implicit one. Let the RPC server handle the
// request as given. // request as given.
params.pushKVEnd("args", positional_args); params.pushKVEnd("args", std::move(positional_args));
} }
return params; return params;

4
src/rpc/external_signer.cpp
View file

@ -53,13 +53,13 @@ static RPCHelpMan enumeratesigners()
UniValue signer_res = UniValue::VOBJ; UniValue signer_res = UniValue::VOBJ;
signer_res.pushKV("fingerprint", signer.m_fingerprint); signer_res.pushKV("fingerprint", signer.m_fingerprint);
signer_res.pushKV("name", signer.m_name); signer_res.pushKV("name", signer.m_name);
signers_res.push_back(signer_res); signers_res.push_back(std::move(signer_res));
} }
} catch (const std::exception& e) { } catch (const std::exception& e) {
throw JSONRPCError(RPC_MISC_ERROR, e.what()); throw JSONRPCError(RPC_MISC_ERROR, e.what());
} }
UniValue result(UniValue::VOBJ); UniValue result(UniValue::VOBJ);
result.pushKV("signers", signers_res); result.pushKV("signers", std::move(signers_res));
return result; return result;
} }
}; };

12
src/rpc/fees.cpp
View file

@ -88,7 +88,7 @@ static RPCHelpMan estimatesmartfee()
result.pushKV("feerate", ValueFromAmount(feeRate.GetFeePerK())); result.pushKV("feerate", ValueFromAmount(feeRate.GetFeePerK()));
} else { } else {
errors.push_back("Insufficient data or no feerate found"); errors.push_back("Insufficient data or no feerate found");
result.pushKV("errors", errors); result.pushKV("errors", std::move(errors));
} }
result.pushKV("blocks", feeCalc.returnedTarget); result.pushKV("blocks", feeCalc.returnedTarget);
return result; return result;
@ -198,18 +198,18 @@ static RPCHelpMan estimaterawfee()
horizon_result.pushKV("feerate", ValueFromAmount(feeRate.GetFeePerK())); horizon_result.pushKV("feerate", ValueFromAmount(feeRate.GetFeePerK()));
horizon_result.pushKV("decay", buckets.decay); horizon_result.pushKV("decay", buckets.decay);
horizon_result.pushKV("scale", (int)buckets.scale); horizon_result.pushKV("scale", (int)buckets.scale);
horizon_result.pushKV("pass", passbucket); horizon_result.pushKV("pass", std::move(passbucket));
// buckets.fail.start == -1 indicates that all buckets passed, there is no fail bucket to output // buckets.fail.start == -1 indicates that all buckets passed, there is no fail bucket to output
if (buckets.fail.start != -1) horizon_result.pushKV("fail", failbucket); if (buckets.fail.start != -1) horizon_result.pushKV("fail", std::move(failbucket));
} else { } else {
// Output only information that is still meaningful in the event of error // Output only information that is still meaningful in the event of error
horizon_result.pushKV("decay", buckets.decay); horizon_result.pushKV("decay", buckets.decay);
horizon_result.pushKV("scale", (int)buckets.scale); horizon_result.pushKV("scale", (int)buckets.scale);
horizon_result.pushKV("fail", failbucket); horizon_result.pushKV("fail", std::move(failbucket));
errors.push_back("Insufficient data or no feerate found which meets threshold"); errors.push_back("Insufficient data or no feerate found which meets threshold");
horizon_result.pushKV("errors", errors); horizon_result.pushKV("errors", std::move(errors));
} }
result.pushKV(StringForFeeEstimateHorizon(horizon), horizon_result); result.pushKV(StringForFeeEstimateHorizon(horizon), std::move(horizon_result));
} }
return result; return result;
}, },

34
src/rpc/mempool.cpp
View file

@ -202,7 +202,7 @@ static RPCHelpMan testmempoolaccept()
auto it = package_result.m_tx_results.find(tx->GetWitnessHash()); auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
if (exit_early || it == package_result.m_tx_results.end()) { if (exit_early || it == package_result.m_tx_results.end()) {
// Validation unfinished. Just return the txid and wtxid. // Validation unfinished. Just return the txid and wtxid.
rpc_result.push_back(result_inner); rpc_result.push_back(std::move(result_inner));
continue; continue;
} }
const auto& tx_result = it->second; const auto& tx_result = it->second;
@ -229,8 +229,8 @@ static RPCHelpMan testmempoolaccept()
for (const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) { for (const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
effective_includes_res.push_back(wtxid.ToString()); effective_includes_res.push_back(wtxid.ToString());
} }
fees.pushKV("effective-includes", effective_includes_res); fees.pushKV("effective-includes", std::move(effective_includes_res));
result_inner.pushKV("fees", fees); result_inner.pushKV("fees", std::move(fees));
} }
} else { } else {
result_inner.pushKV("allowed", false); result_inner.pushKV("allowed", false);
@ -241,7 +241,7 @@ static RPCHelpMan testmempoolaccept()
result_inner.pushKV("reject-reason", state.GetRejectReason()); result_inner.pushKV("reject-reason", state.GetRejectReason());
} }
} }
rpc_result.push_back(result_inner); rpc_result.push_back(std::move(result_inner));
} }
return rpc_result; return rpc_result;
}, },
@ -295,7 +295,7 @@ static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPool
fees.pushKV("modified", ValueFromAmount(e.GetModifiedFee())); fees.pushKV("modified", ValueFromAmount(e.GetModifiedFee()));
fees.pushKV("ancestor", ValueFromAmount(e.GetModFeesWithAncestors())); fees.pushKV("ancestor", ValueFromAmount(e.GetModFeesWithAncestors()));
fees.pushKV("descendant", ValueFromAmount(e.GetModFeesWithDescendants())); fees.pushKV("descendant", ValueFromAmount(e.GetModFeesWithDescendants()));
info.pushKV("fees", fees); info.pushKV("fees", std::move(fees));
const CTransaction& tx = e.GetTx(); const CTransaction& tx = e.GetTx();
std::set<std::string> setDepends; std::set<std::string> setDepends;
@ -311,14 +311,14 @@ static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPool
depends.push_back(dep); depends.push_back(dep);
} }
info.pushKV("depends", depends); info.pushKV("depends", std::move(depends));
UniValue spent(UniValue::VARR); UniValue spent(UniValue::VARR);
for (const CTxMemPoolEntry& child : e.GetMemPoolChildrenConst()) { for (const CTxMemPoolEntry& child : e.GetMemPoolChildrenConst()) {
spent.push_back(child.GetTx().GetHash().ToString()); spent.push_back(child.GetTx().GetHash().ToString());
} }
info.pushKV("spentby", spent); info.pushKV("spentby", std::move(spent));
// Add opt-in RBF status // Add opt-in RBF status
bool rbfStatus = false; bool rbfStatus = false;
@ -347,7 +347,7 @@ UniValue MempoolToJSON(const CTxMemPool& pool, bool verbose, bool include_mempoo
// Mempool has unique entries so there is no advantage in using // Mempool has unique entries so there is no advantage in using
// UniValue::pushKV, which checks if the key already exists in O(N). // UniValue::pushKV, which checks if the key already exists in O(N).
// UniValue::pushKVEnd is used instead which currently is O(1). // UniValue::pushKVEnd is used instead which currently is O(1).
o.pushKVEnd(e.GetTx().GetHash().ToString(), info); o.pushKVEnd(e.GetTx().GetHash().ToString(), std::move(info));
} }
return o; return o;
} else { } else {
@ -364,7 +364,7 @@ UniValue MempoolToJSON(const CTxMemPool& pool, bool verbose, bool include_mempoo
return a; return a;
} else { } else {
UniValue o(UniValue::VOBJ); UniValue o(UniValue::VOBJ);
o.pushKV("txids", a); o.pushKV("txids", std::move(a));
o.pushKV("mempool_sequence", mempool_sequence); o.pushKV("mempool_sequence", mempool_sequence);
return o; return o;
} }
@ -474,7 +474,7 @@ static RPCHelpMan getmempoolancestors()
const uint256& _hash = e.GetTx().GetHash(); const uint256& _hash = e.GetTx().GetHash();
UniValue info(UniValue::VOBJ); UniValue info(UniValue::VOBJ);
entryToJSON(mempool, info, e); entryToJSON(mempool, info, e);
o.pushKV(_hash.ToString(), info); o.pushKV(_hash.ToString(), std::move(info));
} }
return o; return o;
} }
@ -539,7 +539,7 @@ static RPCHelpMan getmempooldescendants()
const uint256& _hash = e.GetTx().GetHash(); const uint256& _hash = e.GetTx().GetHash();
UniValue info(UniValue::VOBJ); UniValue info(UniValue::VOBJ);
entryToJSON(mempool, info, e); entryToJSON(mempool, info, e);
o.pushKV(_hash.ToString(), info); o.pushKV(_hash.ToString(), std::move(info));
} }
return o; return o;
} }
@ -653,7 +653,7 @@ static RPCHelpMan gettxspendingprevout()
o.pushKV("spendingtxid", spendingTx->GetHash().ToString()); o.pushKV("spendingtxid", spendingTx->GetHash().ToString());
} }
result.push_back(o); result.push_back(std::move(o));
} }
return result; return result;
@ -992,20 +992,20 @@ static RPCHelpMan submitpackage()
for (const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) { for (const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
effective_includes_res.push_back(wtxid.ToString()); effective_includes_res.push_back(wtxid.ToString());
} }
fees.pushKV("effective-includes", effective_includes_res); fees.pushKV("effective-includes", std::move(effective_includes_res));
} }
result_inner.pushKV("fees", fees); result_inner.pushKV("fees", std::move(fees));
for (const auto& ptx : it->second.m_replaced_transactions) { for (const auto& ptx : it->second.m_replaced_transactions) {
replaced_txids.insert(ptx->GetHash()); replaced_txids.insert(ptx->GetHash());
} }
break; break;
} }
tx_result_map.pushKV(tx->GetWitnessHash().GetHex(), result_inner); tx_result_map.pushKV(tx->GetWitnessHash().GetHex(), std::move(result_inner));
} }
rpc_result.pushKV("tx-results", tx_result_map); rpc_result.pushKV("tx-results", std::move(tx_result_map));
UniValue replaced_list(UniValue::VARR); UniValue replaced_list(UniValue::VARR);
for (const uint256& hash : replaced_txids) replaced_list.push_back(hash.ToString()); for (const uint256& hash : replaced_txids) replaced_list.push_back(hash.ToString());
rpc_result.pushKV("replaced-transactions", replaced_list); rpc_result.pushKV("replaced-transactions", std::move(replaced_list));
return rpc_result; return rpc_result;
}, },
}; };

18
src/rpc/mining.cpp
View file

@ -529,7 +529,7 @@ static RPCHelpMan getprioritisedtransactions()
if (delta_info.in_mempool) { if (delta_info.in_mempool) {
result_inner.pushKV("modified_fee", *delta_info.modified_fee); result_inner.pushKV("modified_fee", *delta_info.modified_fee);
} }
rpc_result.pushKV(delta_info.txid.GetHex(), result_inner); rpc_result.pushKV(delta_info.txid.GetHex(), std::move(result_inner));
} }
return rpc_result; return rpc_result;
}, },
@ -854,7 +854,7 @@ static RPCHelpMan getblocktemplate()
if (setTxIndex.count(in.prevout.hash)) if (setTxIndex.count(in.prevout.hash))
deps.push_back(setTxIndex[in.prevout.hash]); deps.push_back(setTxIndex[in.prevout.hash]);
} }
entry.pushKV("depends", deps); entry.pushKV("depends", std::move(deps));
int index_in_template = i - 1; int index_in_template = i - 1;
entry.pushKV("fee", pblocktemplate->vTxFees[index_in_template]); entry.pushKV("fee", pblocktemplate->vTxFees[index_in_template]);
@ -866,7 +866,7 @@ static RPCHelpMan getblocktemplate()
entry.pushKV("sigops", nTxSigOps); entry.pushKV("sigops", nTxSigOps);
entry.pushKV("weight", GetTransactionWeight(tx)); entry.pushKV("weight", GetTransactionWeight(tx));
transactions.push_back(entry); transactions.push_back(std::move(entry));
} }
UniValue aux(UniValue::VOBJ); UniValue aux(UniValue::VOBJ);
@ -879,7 +879,7 @@ static RPCHelpMan getblocktemplate()
aMutable.push_back("prevblock"); aMutable.push_back("prevblock");
UniValue result(UniValue::VOBJ); UniValue result(UniValue::VOBJ);
result.pushKV("capabilities", aCaps); result.pushKV("capabilities", std::move(aCaps));
UniValue aRules(UniValue::VARR); UniValue aRules(UniValue::VARR);
aRules.push_back("csv"); aRules.push_back("csv");
@ -931,18 +931,18 @@ static RPCHelpMan getblocktemplate()
} }
} }
result.pushKV("version", pblock->nVersion); result.pushKV("version", pblock->nVersion);
result.pushKV("rules", aRules); result.pushKV("rules", std::move(aRules));
result.pushKV("vbavailable", vbavailable); result.pushKV("vbavailable", std::move(vbavailable));
result.pushKV("vbrequired", int(0)); result.pushKV("vbrequired", int(0));
result.pushKV("previousblockhash", pblock->hashPrevBlock.GetHex()); result.pushKV("previousblockhash", pblock->hashPrevBlock.GetHex());
result.pushKV("transactions", transactions); result.pushKV("transactions", std::move(transactions));
result.pushKV("coinbaseaux", aux); result.pushKV("coinbaseaux", std::move(aux));
result.pushKV("coinbasevalue", (int64_t)pblock->vtx[0]->vout[0].nValue); result.pushKV("coinbasevalue", (int64_t)pblock->vtx[0]->vout[0].nValue);
result.pushKV("longpollid", active_chain.Tip()->GetBlockHash().GetHex() + ToString(nTransactionsUpdatedLast)); result.pushKV("longpollid", active_chain.Tip()->GetBlockHash().GetHex() + ToString(nTransactionsUpdatedLast));
result.pushKV("target", hashTarget.GetHex()); result.pushKV("target", hashTarget.GetHex());
result.pushKV("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1); result.pushKV("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1);
result.pushKV("mutable", aMutable); result.pushKV("mutable", std::move(aMutable));
result.pushKV("noncerange", "00000000ffffffff"); result.pushKV("noncerange", "00000000ffffffff");
int64_t nSigOpLimit = MAX_BLOCK_SIGOPS_COST; int64_t nSigOpLimit = MAX_BLOCK_SIGOPS_COST;
int64_t nSizeLimit = MAX_BLOCK_SERIALIZED_SIZE; int64_t nSizeLimit = MAX_BLOCK_SERIALIZED_SIZE;

32
src/rpc/net.cpp
View file

@ -263,7 +263,7 @@ static RPCHelpMan getpeerinfo()
for (const int height : statestats.vHeightInFlight) { for (const int height : statestats.vHeightInFlight) {
heights.push_back(height); heights.push_back(height);
} }
obj.pushKV("inflight", heights); obj.pushKV("inflight", std::move(heights));
obj.pushKV("addr_relay_enabled", statestats.m_addr_relay_enabled); obj.pushKV("addr_relay_enabled", statestats.m_addr_relay_enabled);
obj.pushKV("addr_processed", statestats.m_addr_processed); obj.pushKV("addr_processed", statestats.m_addr_processed);
obj.pushKV("addr_rate_limited", statestats.m_addr_rate_limited); obj.pushKV("addr_rate_limited", statestats.m_addr_rate_limited);
@ -271,7 +271,7 @@ static RPCHelpMan getpeerinfo()
for (const auto& permission : NetPermissions::ToStrings(stats.m_permission_flags)) { for (const auto& permission : NetPermissions::ToStrings(stats.m_permission_flags)) {
permissions.push_back(permission); permissions.push_back(permission);
} }
obj.pushKV("permissions", permissions); obj.pushKV("permissions", std::move(permissions));
obj.pushKV("minfeefilter", ValueFromAmount(statestats.m_fee_filter_received)); obj.pushKV("minfeefilter", ValueFromAmount(statestats.m_fee_filter_received));
UniValue sendPerMsgType(UniValue::VOBJ); UniValue sendPerMsgType(UniValue::VOBJ);
@ -279,19 +279,19 @@ static RPCHelpMan getpeerinfo()
if (i.second > 0) if (i.second > 0)
sendPerMsgType.pushKV(i.first, i.second); sendPerMsgType.pushKV(i.first, i.second);
} }
obj.pushKV("bytessent_per_msg", sendPerMsgType); obj.pushKV("bytessent_per_msg", std::move(sendPerMsgType));
UniValue recvPerMsgType(UniValue::VOBJ); UniValue recvPerMsgType(UniValue::VOBJ);
for (const auto& i : stats.mapRecvBytesPerMsgType) { for (const auto& i : stats.mapRecvBytesPerMsgType) {
if (i.second > 0) if (i.second > 0)
recvPerMsgType.pushKV(i.first, i.second); recvPerMsgType.pushKV(i.first, i.second);
} }
obj.pushKV("bytesrecv_per_msg", recvPerMsgType); obj.pushKV("bytesrecv_per_msg", std::move(recvPerMsgType));
obj.pushKV("connection_type", ConnectionTypeAsString(stats.m_conn_type)); obj.pushKV("connection_type", ConnectionTypeAsString(stats.m_conn_type));
obj.pushKV("transport_protocol_type", TransportTypeAsString(stats.m_transport_type)); obj.pushKV("transport_protocol_type", TransportTypeAsString(stats.m_transport_type));
obj.pushKV("session_id", stats.m_session_id); obj.pushKV("session_id", stats.m_session_id);
ret.push_back(obj); ret.push_back(std::move(obj));
} }
return ret; return ret;
@ -532,10 +532,10 @@ static RPCHelpMan getaddednodeinfo()
UniValue address(UniValue::VOBJ); UniValue address(UniValue::VOBJ);
address.pushKV("address", info.resolvedAddress.ToStringAddrPort()); address.pushKV("address", info.resolvedAddress.ToStringAddrPort());
address.pushKV("connected", info.fInbound ? "inbound" : "outbound"); address.pushKV("connected", info.fInbound ? "inbound" : "outbound");
addresses.push_back(address); addresses.push_back(std::move(address));
} }
obj.pushKV("addresses", addresses); obj.pushKV("addresses", std::move(addresses));
ret.push_back(obj); ret.push_back(std::move(obj));
} }
return ret; return ret;
@ -587,7 +587,7 @@ static RPCHelpMan getnettotals()
outboundLimit.pushKV("serve_historical_blocks", !connman.OutboundTargetReached(true)); outboundLimit.pushKV("serve_historical_blocks", !connman.OutboundTargetReached(true));
outboundLimit.pushKV("bytes_left_in_cycle", connman.GetOutboundTargetBytesLeft()); outboundLimit.pushKV("bytes_left_in_cycle", connman.GetOutboundTargetBytesLeft());
outboundLimit.pushKV("time_left_in_cycle", count_seconds(connman.GetMaxOutboundTimeLeftInCycle())); outboundLimit.pushKV("time_left_in_cycle", count_seconds(connman.GetMaxOutboundTimeLeftInCycle()));
obj.pushKV("uploadtarget", outboundLimit); obj.pushKV("uploadtarget", std::move(outboundLimit));
return obj; return obj;
}, },
}; };
@ -607,7 +607,7 @@ static UniValue GetNetworksInfo()
obj.pushKV("reachable", g_reachable_nets.Contains(network)); obj.pushKV("reachable", g_reachable_nets.Contains(network));
obj.pushKV("proxy", proxy.IsValid() ? proxy.ToString() : std::string()); obj.pushKV("proxy", proxy.IsValid() ? proxy.ToString() : std::string());
obj.pushKV("proxy_randomize_credentials", proxy.m_randomize_credentials); obj.pushKV("proxy_randomize_credentials", proxy.m_randomize_credentials);
networks.push_back(obj); networks.push_back(std::move(obj));
} }
return networks; return networks;
} }
@ -709,10 +709,10 @@ static RPCHelpMan getnetworkinfo()
rec.pushKV("address", item.first.ToStringAddr()); rec.pushKV("address", item.first.ToStringAddr());
rec.pushKV("port", item.second.nPort); rec.pushKV("port", item.second.nPort);
rec.pushKV("score", item.second.nScore); rec.pushKV("score", item.second.nScore);
localAddresses.push_back(rec); localAddresses.push_back(std::move(rec));
} }
} }
obj.pushKV("localaddresses", localAddresses); obj.pushKV("localaddresses", std::move(localAddresses));
obj.pushKV("warnings", GetNodeWarnings(IsDeprecatedRPCEnabled("warnings"))); obj.pushKV("warnings", GetNodeWarnings(IsDeprecatedRPCEnabled("warnings")));
return obj; return obj;
}, },
@ -843,7 +843,7 @@ static RPCHelpMan listbanned()
rec.pushKV("ban_duration", (banEntry.nBanUntil - banEntry.nCreateTime)); rec.pushKV("ban_duration", (banEntry.nBanUntil - banEntry.nCreateTime));
rec.pushKV("time_remaining", (banEntry.nBanUntil - current_time)); rec.pushKV("time_remaining", (banEntry.nBanUntil - current_time));
bannedAddresses.push_back(rec); bannedAddresses.push_back(std::move(rec));
} }
return bannedAddresses; return bannedAddresses;
@ -947,7 +947,7 @@ static RPCHelpMan getnodeaddresses()
obj.pushKV("address", addr.ToStringAddr()); obj.pushKV("address", addr.ToStringAddr());
obj.pushKV("port", addr.GetPort()); obj.pushKV("port", addr.GetPort());
obj.pushKV("network", GetNetworkName(addr.GetNetClass())); obj.pushKV("network", GetNetworkName(addr.GetNetClass()));
ret.push_back(obj); ret.push_back(std::move(obj));
} }
return ret; return ret;
}, },
@ -1087,13 +1087,13 @@ static RPCHelpMan getaddrmaninfo()
obj.pushKV("new", addrman.Size(network, true)); obj.pushKV("new", addrman.Size(network, true));
obj.pushKV("tried", addrman.Size(network, false)); obj.pushKV("tried", addrman.Size(network, false));
obj.pushKV("total", addrman.Size(network)); obj.pushKV("total", addrman.Size(network));
ret.pushKV(GetNetworkName(network), obj); ret.pushKV(GetNetworkName(network), std::move(obj));
} }
UniValue obj(UniValue::VOBJ); UniValue obj(UniValue::VOBJ);
obj.pushKV("new", addrman.Size(std::nullopt, true)); obj.pushKV("new", addrman.Size(std::nullopt, true));
obj.pushKV("tried", addrman.Size(std::nullopt, false)); obj.pushKV("tried", addrman.Size(std::nullopt, false));
obj.pushKV("total", addrman.Size()); obj.pushKV("total", addrman.Size());
ret.pushKV("all_networks", obj); ret.pushKV("all_networks", std::move(obj));
return ret; return ret;
}, },
}; };

2
src/rpc/node.cpp
View file

@ -351,7 +351,7 @@ static UniValue SummaryToJSON(const IndexSummary&& summary, std::string index_na
UniValue entry(UniValue::VOBJ); UniValue entry(UniValue::VOBJ);
entry.pushKV("synced", summary.synced); entry.pushKV("synced", summary.synced);
entry.pushKV("best_block_height", summary.best_block_height); entry.pushKV("best_block_height", summary.best_block_height);
ret_summary.pushKV(summary.name, entry); ret_summary.pushKV(summary.name, std::move(entry));
return ret_summary; return ret_summary;
} }

4
src/rpc/output_script.cpp
View file

@ -72,11 +72,11 @@ static RPCHelpMan validateaddress()
ret.pushKV("scriptPubKey", HexStr(scriptPubKey)); ret.pushKV("scriptPubKey", HexStr(scriptPubKey));
UniValue detail = DescribeAddress(dest); UniValue detail = DescribeAddress(dest);
ret.pushKVs(detail); ret.pushKVs(std::move(detail));
} else { } else {
UniValue error_indices(UniValue::VARR); UniValue error_indices(UniValue::VARR);
for (int i : error_locations) error_indices.push_back(i); for (int i : error_locations) error_indices.push_back(i);
ret.pushKV("error_locations", error_indices); ret.pushKV("error_locations", std::move(error_indices));
ret.pushKV("error", error_msg); ret.pushKV("error", error_msg);
} }

106
src/rpc/rawtransaction.cpp
View file

@ -618,7 +618,7 @@ static RPCHelpMan decodescript()
} }
ScriptToUniv(segwitScr, /*out=*/sr, /*include_hex=*/true, /*include_address=*/true, /*provider=*/&provider); ScriptToUniv(segwitScr, /*out=*/sr, /*include_hex=*/true, /*include_address=*/true, /*provider=*/&provider);
sr.pushKV("p2sh-segwit", EncodeDestination(ScriptHash(segwitScr))); sr.pushKV("p2sh-segwit", EncodeDestination(ScriptHash(segwitScr)));
r.pushKV("segwit", sr); r.pushKV("segwit", std::move(sr));
} }
} }
@ -1069,7 +1069,7 @@ static RPCHelpMan decodepsbt()
// Add the decoded tx // Add the decoded tx
UniValue tx_univ(UniValue::VOBJ); UniValue tx_univ(UniValue::VOBJ);
TxToUniv(CTransaction(*psbtx.tx), /*block_hash=*/uint256(), /*entry=*/tx_univ, /*include_hex=*/false); TxToUniv(CTransaction(*psbtx.tx), /*block_hash=*/uint256(), /*entry=*/tx_univ, /*include_hex=*/false);
result.pushKV("tx", tx_univ); result.pushKV("tx", std::move(tx_univ));
// Add the global xpubs // Add the global xpubs
UniValue global_xpubs(UniValue::VARR); UniValue global_xpubs(UniValue::VARR);
@ -1083,10 +1083,10 @@ static RPCHelpMan decodepsbt()
keypath.pushKV("xpub", EncodeBase58Check(ser_xpub)); keypath.pushKV("xpub", EncodeBase58Check(ser_xpub));
keypath.pushKV("master_fingerprint", HexStr(Span<unsigned char>(xpub_pair.first.fingerprint, xpub_pair.first.fingerprint + 4))); keypath.pushKV("master_fingerprint", HexStr(Span<unsigned char>(xpub_pair.first.fingerprint, xpub_pair.first.fingerprint + 4)));
keypath.pushKV("path", WriteHDKeypath(xpub_pair.first.path)); keypath.pushKV("path", WriteHDKeypath(xpub_pair.first.path));
global_xpubs.push_back(keypath); global_xpubs.push_back(std::move(keypath));
} }
} }
result.pushKV("global_xpubs", global_xpubs); result.pushKV("global_xpubs", std::move(global_xpubs));
// PSBT version // PSBT version
result.pushKV("psbt_version", static_cast<uint64_t>(psbtx.GetVersion())); result.pushKV("psbt_version", static_cast<uint64_t>(psbtx.GetVersion()));
@ -1099,16 +1099,16 @@ static RPCHelpMan decodepsbt()
this_prop.pushKV("subtype", entry.subtype); this_prop.pushKV("subtype", entry.subtype);
this_prop.pushKV("key", HexStr(entry.key)); this_prop.pushKV("key", HexStr(entry.key));
this_prop.pushKV("value", HexStr(entry.value)); this_prop.pushKV("value", HexStr(entry.value));
proprietary.push_back(this_prop); proprietary.push_back(std::move(this_prop));
} }
result.pushKV("proprietary", proprietary); result.pushKV("proprietary", std::move(proprietary));
// Unknown data // Unknown data
UniValue unknowns(UniValue::VOBJ); UniValue unknowns(UniValue::VOBJ);
for (auto entry : psbtx.unknown) { for (auto entry : psbtx.unknown) {
unknowns.pushKV(HexStr(entry.first), HexStr(entry.second)); unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
} }
result.pushKV("unknown", unknowns); result.pushKV("unknown", std::move(unknowns));
// inputs // inputs
CAmount total_in = 0; CAmount total_in = 0;
@ -1128,9 +1128,9 @@ static RPCHelpMan decodepsbt()
UniValue out(UniValue::VOBJ); UniValue out(UniValue::VOBJ);
out.pushKV("amount", ValueFromAmount(txout.nValue)); out.pushKV("amount", ValueFromAmount(txout.nValue));
out.pushKV("scriptPubKey", o); out.pushKV("scriptPubKey", std::move(o));
in.pushKV("witness_utxo", out); in.pushKV("witness_utxo", std::move(out));
have_a_utxo = true; have_a_utxo = true;
} }
@ -1139,7 +1139,7 @@ static RPCHelpMan decodepsbt()
UniValue non_wit(UniValue::VOBJ); UniValue non_wit(UniValue::VOBJ);
TxToUniv(*input.non_witness_utxo, /*block_hash=*/uint256(), /*entry=*/non_wit, /*include_hex=*/false); TxToUniv(*input.non_witness_utxo, /*block_hash=*/uint256(), /*entry=*/non_wit, /*include_hex=*/false);
in.pushKV("non_witness_utxo", non_wit); in.pushKV("non_witness_utxo", std::move(non_wit));
have_a_utxo = true; have_a_utxo = true;
} }
@ -1160,7 +1160,7 @@ static RPCHelpMan decodepsbt()
for (const auto& sig : input.partial_sigs) { for (const auto& sig : input.partial_sigs) {
partial_sigs.pushKV(HexStr(sig.second.first), HexStr(sig.second.second)); partial_sigs.pushKV(HexStr(sig.second.first), HexStr(sig.second.second));
} }
in.pushKV("partial_signatures", partial_sigs); in.pushKV("partial_signatures", std::move(partial_sigs));
} }
// Sighash // Sighash
@ -1172,12 +1172,12 @@ static RPCHelpMan decodepsbt()
if (!input.redeem_script.empty()) { if (!input.redeem_script.empty()) {
UniValue r(UniValue::VOBJ); UniValue r(UniValue::VOBJ);
ScriptToUniv(input.redeem_script, /*out=*/r); ScriptToUniv(input.redeem_script, /*out=*/r);
in.pushKV("redeem_script", r); in.pushKV("redeem_script", std::move(r));
} }
if (!input.witness_script.empty()) { if (!input.witness_script.empty()) {
UniValue r(UniValue::VOBJ); UniValue r(UniValue::VOBJ);
ScriptToUniv(input.witness_script, /*out=*/r); ScriptToUniv(input.witness_script, /*out=*/r);
in.pushKV("witness_script", r); in.pushKV("witness_script", std::move(r));
} }
// keypaths // keypaths
@ -1189,9 +1189,9 @@ static RPCHelpMan decodepsbt()
keypath.pushKV("master_fingerprint", strprintf("%08x", ReadBE32(entry.second.fingerprint))); keypath.pushKV("master_fingerprint", strprintf("%08x", ReadBE32(entry.second.fingerprint)));
keypath.pushKV("path", WriteHDKeypath(entry.second.path)); keypath.pushKV("path", WriteHDKeypath(entry.second.path));
keypaths.push_back(keypath); keypaths.push_back(std::move(keypath));
} }
in.pushKV("bip32_derivs", keypaths); in.pushKV("bip32_derivs", std::move(keypaths));
} }
// Final scriptSig and scriptwitness // Final scriptSig and scriptwitness
@ -1199,14 +1199,14 @@ static RPCHelpMan decodepsbt()
UniValue scriptsig(UniValue::VOBJ); UniValue scriptsig(UniValue::VOBJ);
scriptsig.pushKV("asm", ScriptToAsmStr(input.final_script_sig, true)); scriptsig.pushKV("asm", ScriptToAsmStr(input.final_script_sig, true));
scriptsig.pushKV("hex", HexStr(input.final_script_sig)); scriptsig.pushKV("hex", HexStr(input.final_script_sig));
in.pushKV("final_scriptSig", scriptsig); in.pushKV("final_scriptSig", std::move(scriptsig));
} }
if (!input.final_script_witness.IsNull()) { if (!input.final_script_witness.IsNull()) {
UniValue txinwitness(UniValue::VARR); UniValue txinwitness(UniValue::VARR);
for (const auto& item : input.final_script_witness.stack) { for (const auto& item : input.final_script_witness.stack) {
txinwitness.push_back(HexStr(item)); txinwitness.push_back(HexStr(item));
} }
in.pushKV("final_scriptwitness", txinwitness); in.pushKV("final_scriptwitness", std::move(txinwitness));
} }
// Ripemd160 hash preimages // Ripemd160 hash preimages
@ -1215,7 +1215,7 @@ static RPCHelpMan decodepsbt()
for (const auto& [hash, preimage] : input.ripemd160_preimages) { for (const auto& [hash, preimage] : input.ripemd160_preimages) {
ripemd160_preimages.pushKV(HexStr(hash), HexStr(preimage)); ripemd160_preimages.pushKV(HexStr(hash), HexStr(preimage));
} }
in.pushKV("ripemd160_preimages", ripemd160_preimages); in.pushKV("ripemd160_preimages", std::move(ripemd160_preimages));
} }
// Sha256 hash preimages // Sha256 hash preimages
@ -1224,7 +1224,7 @@ static RPCHelpMan decodepsbt()
for (const auto& [hash, preimage] : input.sha256_preimages) { for (const auto& [hash, preimage] : input.sha256_preimages) {
sha256_preimages.pushKV(HexStr(hash), HexStr(preimage)); sha256_preimages.pushKV(HexStr(hash), HexStr(preimage));
} }
in.pushKV("sha256_preimages", sha256_preimages); in.pushKV("sha256_preimages", std::move(sha256_preimages));
} }
// Hash160 hash preimages // Hash160 hash preimages
@ -1233,7 +1233,7 @@ static RPCHelpMan decodepsbt()
for (const auto& [hash, preimage] : input.hash160_preimages) { for (const auto& [hash, preimage] : input.hash160_preimages) {
hash160_preimages.pushKV(HexStr(hash), HexStr(preimage)); hash160_preimages.pushKV(HexStr(hash), HexStr(preimage));
} }
in.pushKV("hash160_preimages", hash160_preimages); in.pushKV("hash160_preimages", std::move(hash160_preimages));
} }
// Hash256 hash preimages // Hash256 hash preimages
@ -1242,7 +1242,7 @@ static RPCHelpMan decodepsbt()
for (const auto& [hash, preimage] : input.hash256_preimages) { for (const auto& [hash, preimage] : input.hash256_preimages) {
hash256_preimages.pushKV(HexStr(hash), HexStr(preimage)); hash256_preimages.pushKV(HexStr(hash), HexStr(preimage));
} }
in.pushKV("hash256_preimages", hash256_preimages); in.pushKV("hash256_preimages", std::move(hash256_preimages));
} }
// Taproot key path signature // Taproot key path signature
@ -1259,9 +1259,9 @@ static RPCHelpMan decodepsbt()
sigobj.pushKV("pubkey", HexStr(xonly)); sigobj.pushKV("pubkey", HexStr(xonly));
sigobj.pushKV("leaf_hash", HexStr(leaf_hash)); sigobj.pushKV("leaf_hash", HexStr(leaf_hash));
sigobj.pushKV("sig", HexStr(sig)); sigobj.pushKV("sig", HexStr(sig));
script_sigs.push_back(sigobj); script_sigs.push_back(std::move(sigobj));
} }
in.pushKV("taproot_script_path_sigs", script_sigs); in.pushKV("taproot_script_path_sigs", std::move(script_sigs));
} }
// Taproot leaf scripts // Taproot leaf scripts
@ -1276,10 +1276,10 @@ static RPCHelpMan decodepsbt()
for (const auto& control_block : control_blocks) { for (const auto& control_block : control_blocks) {
control_blocks_univ.push_back(HexStr(control_block)); control_blocks_univ.push_back(HexStr(control_block));
} }
script_info.pushKV("control_blocks", control_blocks_univ); script_info.pushKV("control_blocks", std::move(control_blocks_univ));
tap_scripts.push_back(script_info); tap_scripts.push_back(std::move(script_info));
} }
in.pushKV("taproot_scripts", tap_scripts); in.pushKV("taproot_scripts", std::move(tap_scripts));
} }
// Taproot bip32 keypaths // Taproot bip32 keypaths
@ -1295,10 +1295,10 @@ static RPCHelpMan decodepsbt()
for (const auto& leaf_hash : leaf_hashes) { for (const auto& leaf_hash : leaf_hashes) {
leaf_hashes_arr.push_back(HexStr(leaf_hash)); leaf_hashes_arr.push_back(HexStr(leaf_hash));
} }
path_obj.pushKV("leaf_hashes", leaf_hashes_arr); path_obj.pushKV("leaf_hashes", std::move(leaf_hashes_arr));
keypaths.push_back(path_obj); keypaths.push_back(std::move(path_obj));
} }
in.pushKV("taproot_bip32_derivs", keypaths); in.pushKV("taproot_bip32_derivs", std::move(keypaths));
} }
// Taproot internal key // Taproot internal key
@ -1320,9 +1320,9 @@ static RPCHelpMan decodepsbt()
this_prop.pushKV("subtype", entry.subtype); this_prop.pushKV("subtype", entry.subtype);
this_prop.pushKV("key", HexStr(entry.key)); this_prop.pushKV("key", HexStr(entry.key));
this_prop.pushKV("value", HexStr(entry.value)); this_prop.pushKV("value", HexStr(entry.value));
proprietary.push_back(this_prop); proprietary.push_back(std::move(this_prop));
} }
in.pushKV("proprietary", proprietary); in.pushKV("proprietary", std::move(proprietary));
} }
// Unknown data // Unknown data
@ -1331,12 +1331,12 @@ static RPCHelpMan decodepsbt()
for (auto entry : input.unknown) { for (auto entry : input.unknown) {
unknowns.pushKV(HexStr(entry.first), HexStr(entry.second)); unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
} }
in.pushKV("unknown", unknowns); in.pushKV("unknown", std::move(unknowns));
} }
inputs.push_back(in); inputs.push_back(std::move(in));
} }
result.pushKV("inputs", inputs); result.pushKV("inputs", std::move(inputs));
// outputs // outputs
CAmount output_value = 0; CAmount output_value = 0;
@ -1348,12 +1348,12 @@ static RPCHelpMan decodepsbt()
if (!output.redeem_script.empty()) { if (!output.redeem_script.empty()) {
UniValue r(UniValue::VOBJ); UniValue r(UniValue::VOBJ);
ScriptToUniv(output.redeem_script, /*out=*/r); ScriptToUniv(output.redeem_script, /*out=*/r);
out.pushKV("redeem_script", r); out.pushKV("redeem_script", std::move(r));
} }
if (!output.witness_script.empty()) { if (!output.witness_script.empty()) {
UniValue r(UniValue::VOBJ); UniValue r(UniValue::VOBJ);
ScriptToUniv(output.witness_script, /*out=*/r); ScriptToUniv(output.witness_script, /*out=*/r);
out.pushKV("witness_script", r); out.pushKV("witness_script", std::move(r));
} }
// keypaths // keypaths
@ -1364,9 +1364,9 @@ static RPCHelpMan decodepsbt()
keypath.pushKV("pubkey", HexStr(entry.first)); keypath.pushKV("pubkey", HexStr(entry.first));
keypath.pushKV("master_fingerprint", strprintf("%08x", ReadBE32(entry.second.fingerprint))); keypath.pushKV("master_fingerprint", strprintf("%08x", ReadBE32(entry.second.fingerprint)));
keypath.pushKV("path", WriteHDKeypath(entry.second.path)); keypath.pushKV("path", WriteHDKeypath(entry.second.path));
keypaths.push_back(keypath); keypaths.push_back(std::move(keypath));
} }
out.pushKV("bip32_derivs", keypaths); out.pushKV("bip32_derivs", std::move(keypaths));
} }
// Taproot internal key // Taproot internal key
@ -1382,9 +1382,9 @@ static RPCHelpMan decodepsbt()
elem.pushKV("depth", (int)depth); elem.pushKV("depth", (int)depth);
elem.pushKV("leaf_ver", (int)leaf_ver); elem.pushKV("leaf_ver", (int)leaf_ver);
elem.pushKV("script", HexStr(script)); elem.pushKV("script", HexStr(script));
tree.push_back(elem); tree.push_back(std::move(elem));
} }
out.pushKV("taproot_tree", tree); out.pushKV("taproot_tree", std::move(tree));
} }
// Taproot bip32 keypaths // Taproot bip32 keypaths
@ -1400,10 +1400,10 @@ static RPCHelpMan decodepsbt()
for (const auto& leaf_hash : leaf_hashes) { for (const auto& leaf_hash : leaf_hashes) {
leaf_hashes_arr.push_back(HexStr(leaf_hash)); leaf_hashes_arr.push_back(HexStr(leaf_hash));
} }
path_obj.pushKV("leaf_hashes", leaf_hashes_arr); path_obj.pushKV("leaf_hashes", std::move(leaf_hashes_arr));
keypaths.push_back(path_obj); keypaths.push_back(std::move(path_obj));
} }
out.pushKV("taproot_bip32_derivs", keypaths); out.pushKV("taproot_bip32_derivs", std::move(keypaths));
} }
// Proprietary // Proprietary
@ -1415,9 +1415,9 @@ static RPCHelpMan decodepsbt()
this_prop.pushKV("subtype", entry.subtype); this_prop.pushKV("subtype", entry.subtype);
this_prop.pushKV("key", HexStr(entry.key)); this_prop.pushKV("key", HexStr(entry.key));
this_prop.pushKV("value", HexStr(entry.value)); this_prop.pushKV("value", HexStr(entry.value));
proprietary.push_back(this_prop); proprietary.push_back(std::move(this_prop));
} }
out.pushKV("proprietary", proprietary); out.pushKV("proprietary", std::move(proprietary));
} }
// Unknown data // Unknown data
@ -1426,10 +1426,10 @@ static RPCHelpMan decodepsbt()
for (auto entry : output.unknown) { for (auto entry : output.unknown) {
unknowns.pushKV(HexStr(entry.first), HexStr(entry.second)); unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
} }
out.pushKV("unknown", unknowns); out.pushKV("unknown", std::move(unknowns));
} }
outputs.push_back(out); outputs.push_back(std::move(out));
// Fee calculation // Fee calculation
if (MoneyRange(psbtx.tx->vout[i].nValue) && MoneyRange(output_value + psbtx.tx->vout[i].nValue)) { if (MoneyRange(psbtx.tx->vout[i].nValue) && MoneyRange(output_value + psbtx.tx->vout[i].nValue)) {
@ -1439,7 +1439,7 @@ static RPCHelpMan decodepsbt()
have_all_utxos = false; have_all_utxos = false;
} }
} }
result.pushKV("outputs", outputs); result.pushKV("outputs", std::move(outputs));
if (have_all_utxos) { if (have_all_utxos) {
result.pushKV("fee", ValueFromAmount(total_in - output_value)); result.pushKV("fee", ValueFromAmount(total_in - output_value));
} }
@ -1876,7 +1876,7 @@ static RPCHelpMan analyzepsbt()
for (const CKeyID& pubkey : input.missing_pubkeys) { for (const CKeyID& pubkey : input.missing_pubkeys) {
missing_pubkeys_univ.push_back(HexStr(pubkey)); missing_pubkeys_univ.push_back(HexStr(pubkey));
} }
missing.pushKV("pubkeys", missing_pubkeys_univ); missing.pushKV("pubkeys", std::move(missing_pubkeys_univ));
} }
if (!input.missing_redeem_script.IsNull()) { if (!input.missing_redeem_script.IsNull()) {
missing.pushKV("redeemscript", HexStr(input.missing_redeem_script)); missing.pushKV("redeemscript", HexStr(input.missing_redeem_script));
@ -1889,14 +1889,14 @@ static RPCHelpMan analyzepsbt()
for (const CKeyID& pubkey : input.missing_sigs) { for (const CKeyID& pubkey : input.missing_sigs) {
missing_sigs_univ.push_back(HexStr(pubkey)); missing_sigs_univ.push_back(HexStr(pubkey));
} }
missing.pushKV("signatures", missing_sigs_univ); missing.pushKV("signatures", std::move(missing_sigs_univ));
} }
if (!missing.getKeys().empty()) { if (!missing.getKeys().empty()) {
input_univ.pushKV("missing", missing); input_univ.pushKV("missing", std::move(missing));
} }
inputs_result.push_back(input_univ); inputs_result.push_back(std::move(input_univ));
} }
if (!inputs_result.empty()) result.pushKV("inputs", inputs_result); if (!inputs_result.empty()) result.pushKV("inputs", std::move(inputs_result));
if (psbta.estimated_vsize != std::nullopt) { if (psbta.estimated_vsize != std::nullopt) {
result.pushKV("estimated_vsize", (int)*psbta.estimated_vsize); result.pushKV("estimated_vsize", (int)*psbta.estimated_vsize);

6
src/rpc/rawtransaction_util.cpp
View file

@ -174,11 +174,11 @@ static void TxInErrorToJSON(const CTxIn& txin, UniValue& vErrorsRet, const std::
for (unsigned int i = 0; i < txin.scriptWitness.stack.size(); i++) { for (unsigned int i = 0; i < txin.scriptWitness.stack.size(); i++) {
witness.push_back(HexStr(txin.scriptWitness.stack[i])); witness.push_back(HexStr(txin.scriptWitness.stack[i]));
} }
entry.pushKV("witness", witness); entry.pushKV("witness", std::move(witness));
entry.pushKV("scriptSig", HexStr(txin.scriptSig)); entry.pushKV("scriptSig", HexStr(txin.scriptSig));
entry.pushKV("sequence", (uint64_t)txin.nSequence); entry.pushKV("sequence", (uint64_t)txin.nSequence);
entry.pushKV("error", strMessage); entry.pushKV("error", strMessage);
vErrorsRet.push_back(entry); vErrorsRet.push_back(std::move(entry));
} }
void ParsePrevouts(const UniValue& prevTxsUnival, FillableSigningProvider* keystore, std::map<COutPoint, Coin>& coins) void ParsePrevouts(const UniValue& prevTxsUnival, FillableSigningProvider* keystore, std::map<COutPoint, Coin>& coins)
@ -331,6 +331,6 @@ void SignTransactionResultToJSON(CMutableTransaction& mtx, bool complete, const
if (result.exists("errors")) { if (result.exists("errors")) {
vErrors.push_backV(result["errors"].getValues()); vErrors.push_backV(result["errors"].getValues());
} }
result.pushKV("errors", vErrors); result.pushKV("errors", std::move(vErrors));
} }
} }

6
src/rpc/server.cpp
View file

@ -241,15 +241,15 @@ static RPCHelpMan getrpcinfo()
UniValue entry(UniValue::VOBJ); UniValue entry(UniValue::VOBJ);
entry.pushKV("method", info.method); entry.pushKV("method", info.method);
entry.pushKV("duration", int64_t{Ticks<std::chrono::microseconds>(SteadyClock::now() - info.start)}); entry.pushKV("duration", int64_t{Ticks<std::chrono::microseconds>(SteadyClock::now() - info.start)});
active_commands.push_back(entry); active_commands.push_back(std::move(entry));
} }
UniValue result(UniValue::VOBJ); UniValue result(UniValue::VOBJ);
result.pushKV("active_commands", active_commands); result.pushKV("active_commands", std::move(active_commands));
const std::string path = LogInstance().m_file_path.utf8string(); const std::string path = LogInstance().m_file_path.utf8string();
UniValue log_path(UniValue::VSTR, path); UniValue log_path(UniValue::VSTR, path);
result.pushKV("logpath", log_path); result.pushKV("logpath", std::move(log_path));
return result; return result;
} }

10
src/rpc/util.cpp
View file

@ -645,7 +645,7 @@ UniValue RPCHelpMan::HandleRequest(const JSONRPCRequest& request) const
mismatch.setNull(); mismatch.setNull();
break; break;
} }
mismatch.push_back(match); mismatch.push_back(std::move(match));
} }
if (!mismatch.isNull()) { if (!mismatch.isNull()) {
std::string explain{ std::string explain{
@ -818,7 +818,7 @@ UniValue RPCHelpMan::GetArgMap() const
map.push_back(arg_name); map.push_back(arg_name);
map.push_back(type == RPCArg::Type::STR || map.push_back(type == RPCArg::Type::STR ||
type == RPCArg::Type::STR_HEX); type == RPCArg::Type::STR_HEX);
arr.push_back(map); arr.push_back(std::move(map));
}; };
for (int i{0}; i < int(m_args.size()); ++i) { for (int i{0}; i < int(m_args.size()); ++i) {
@ -1124,7 +1124,7 @@ UniValue RPCResult::MatchesType(const UniValue& result) const
// If there are more results than documented, reuse the last doc_inner. // If there are more results than documented, reuse the last doc_inner.
const RPCResult& doc_inner{m_inner.at(std::min(m_inner.size() - 1, i))}; const RPCResult& doc_inner{m_inner.at(std::min(m_inner.size() - 1, i))};
UniValue match{doc_inner.MatchesType(result.get_array()[i])}; UniValue match{doc_inner.MatchesType(result.get_array()[i])};
if (!match.isTrue()) errors.pushKV(strprintf("%d", i), match); if (!match.isTrue()) errors.pushKV(strprintf("%d", i), std::move(match));
} }
if (errors.empty()) return true; // empty result array is valid if (errors.empty()) return true; // empty result array is valid
return errors; return errors;
@ -1137,7 +1137,7 @@ UniValue RPCResult::MatchesType(const UniValue& result) const
const RPCResult& doc_inner{m_inner.at(0)}; // Assume all types are the same, randomly pick the first const RPCResult& doc_inner{m_inner.at(0)}; // Assume all types are the same, randomly pick the first
for (size_t i{0}; i < result.get_obj().size(); ++i) { for (size_t i{0}; i < result.get_obj().size(); ++i) {
UniValue match{doc_inner.MatchesType(result.get_obj()[i])}; UniValue match{doc_inner.MatchesType(result.get_obj()[i])};
if (!match.isTrue()) errors.pushKV(result.getKeys()[i], match); if (!match.isTrue()) errors.pushKV(result.getKeys()[i], std::move(match));
} }
if (errors.empty()) return true; // empty result obj is valid if (errors.empty()) return true; // empty result obj is valid
return errors; return errors;
@ -1163,7 +1163,7 @@ UniValue RPCResult::MatchesType(const UniValue& result) const
continue; continue;
} }
UniValue match{doc_entry.MatchesType(result_it->second)}; UniValue match{doc_entry.MatchesType(result_it->second)};
if (!match.isTrue()) errors.pushKV(doc_entry.m_key_name, match); if (!match.isTrue()) errors.pushKV(doc_entry.m_key_name, std::move(match));
} }
if (errors.empty()) return true; if (errors.empty()) return true;
return errors; return errors;

2
src/test/script_tests.cpp
View file

@ -396,7 +396,7 @@ public:
wit.push_back(HexStr(scriptWitness.stack[i])); wit.push_back(HexStr(scriptWitness.stack[i]));
} }
wit.push_back(ValueFromAmount(nValue)); wit.push_back(ValueFromAmount(nValue));
array.push_back(wit); array.push_back(std::move(wit));
} }
array.push_back(FormatScript(spendTx.vin[0].scriptSig)); array.push_back(FormatScript(spendTx.vin[0].scriptSig));
array.push_back(FormatScript(creditTx->vout[0].scriptPubKey)); array.push_back(FormatScript(creditTx->vout[0].scriptPubKey));

14
src/wallet/rpc/addresses.cpp
View file

@ -206,9 +206,9 @@ RPCHelpMan listaddressgroupings()
addressInfo.push_back(address_book_entry->GetLabel()); addressInfo.push_back(address_book_entry->GetLabel());
} }
} }
jsonGrouping.push_back(addressInfo); jsonGrouping.push_back(std::move(addressInfo));
} }
jsonGroupings.push_back(jsonGrouping); jsonGroupings.push_back(std::move(jsonGrouping));
} }
return jsonGroupings; return jsonGroupings;
}, },
@ -407,9 +407,9 @@ public:
// Only when the script corresponds to an address. // Only when the script corresponds to an address.
UniValue subobj(UniValue::VOBJ); UniValue subobj(UniValue::VOBJ);
UniValue detail = DescribeAddress(embedded); UniValue detail = DescribeAddress(embedded);
subobj.pushKVs(detail); subobj.pushKVs(std::move(detail));
UniValue wallet_detail = std::visit(*this, embedded); UniValue wallet_detail = std::visit(*this, embedded);
subobj.pushKVs(wallet_detail); subobj.pushKVs(std::move(wallet_detail));
subobj.pushKV("address", EncodeDestination(embedded)); subobj.pushKV("address", EncodeDestination(embedded));
subobj.pushKV("scriptPubKey", HexStr(subscript)); subobj.pushKV("scriptPubKey", HexStr(subscript));
// Always report the pubkey at the top level, so that `getnewaddress()['pubkey']` always works. // Always report the pubkey at the top level, so that `getnewaddress()['pubkey']` always works.
@ -490,7 +490,7 @@ static UniValue DescribeWalletAddress(const CWallet& wallet, const CTxDestinatio
CScript script = GetScriptForDestination(dest); CScript script = GetScriptForDestination(dest);
std::unique_ptr<SigningProvider> provider = nullptr; std::unique_ptr<SigningProvider> provider = nullptr;
provider = wallet.GetSolvingProvider(script); provider = wallet.GetSolvingProvider(script);
ret.pushKVs(detail); ret.pushKVs(std::move(detail));
ret.pushKVs(std::visit(DescribeWalletAddressVisitor(provider.get()), dest)); ret.pushKVs(std::visit(DescribeWalletAddressVisitor(provider.get()), dest));
return ret; return ret;
} }
@ -607,7 +607,7 @@ RPCHelpMan getaddressinfo()
ret.pushKV("iswatchonly", bool(mine & ISMINE_WATCH_ONLY)); ret.pushKV("iswatchonly", bool(mine & ISMINE_WATCH_ONLY));
UniValue detail = DescribeWalletAddress(*pwallet, dest); UniValue detail = DescribeWalletAddress(*pwallet, dest);
ret.pushKVs(detail); ret.pushKVs(std::move(detail));
ret.pushKV("ischange", ScriptIsChange(*pwallet, scriptPubKey)); ret.pushKV("ischange", ScriptIsChange(*pwallet, scriptPubKey));
@ -688,7 +688,7 @@ RPCHelpMan getaddressesbylabel()
// which currently is O(1). // which currently is O(1).
UniValue value(UniValue::VOBJ); UniValue value(UniValue::VOBJ);
value.pushKV("purpose", _purpose ? PurposeToString(*_purpose) : "unknown"); value.pushKV("purpose", _purpose ? PurposeToString(*_purpose) : "unknown");
ret.pushKVEnd(address, value); ret.pushKVEnd(address, std::move(value));
} }
}); });

6
src/wallet/rpc/backup.cpp
View file

@ -1827,16 +1827,16 @@ RPCHelpMan listdescriptors()
UniValue range(UniValue::VARR); UniValue range(UniValue::VARR);
range.push_back(info.range->first); range.push_back(info.range->first);
range.push_back(info.range->second - 1); range.push_back(info.range->second - 1);
spk.pushKV("range", range); spk.pushKV("range", std::move(range));
spk.pushKV("next", info.next_index); spk.pushKV("next", info.next_index);
spk.pushKV("next_index", info.next_index); spk.pushKV("next_index", info.next_index);
} }
descriptors.push_back(spk); descriptors.push_back(std::move(spk));
} }
UniValue response(UniValue::VOBJ); UniValue response(UniValue::VOBJ);
response.pushKV("wallet_name", wallet->GetName()); response.pushKV("wallet_name", wallet->GetName());
response.pushKV("descriptors", descriptors); response.pushKV("descriptors", std::move(descriptors));
return response; return response;
}, },

8
src/wallet/rpc/coins.cpp
View file

@ -416,7 +416,7 @@ RPCHelpMan listlockunspent()
o.pushKV("txid", outpt.hash.GetHex()); o.pushKV("txid", outpt.hash.GetHex());
o.pushKV("vout", (int)outpt.n); o.pushKV("vout", (int)outpt.n);
ret.push_back(o); ret.push_back(std::move(o));
} }
return ret; return ret;
@ -477,7 +477,7 @@ RPCHelpMan getbalances()
const auto full_bal = GetBalance(wallet, 0, false); const auto full_bal = GetBalance(wallet, 0, false);
balances_mine.pushKV("used", ValueFromAmount(full_bal.m_mine_trusted + full_bal.m_mine_untrusted_pending - bal.m_mine_trusted - bal.m_mine_untrusted_pending)); balances_mine.pushKV("used", ValueFromAmount(full_bal.m_mine_trusted + full_bal.m_mine_untrusted_pending - bal.m_mine_trusted - bal.m_mine_untrusted_pending));
} }
balances.pushKV("mine", balances_mine); balances.pushKV("mine", std::move(balances_mine));
} }
auto spk_man = wallet.GetLegacyScriptPubKeyMan(); auto spk_man = wallet.GetLegacyScriptPubKeyMan();
if (spk_man && spk_man->HaveWatchOnly()) { if (spk_man && spk_man->HaveWatchOnly()) {
@ -485,7 +485,7 @@ RPCHelpMan getbalances()
balances_watchonly.pushKV("trusted", ValueFromAmount(bal.m_watchonly_trusted)); balances_watchonly.pushKV("trusted", ValueFromAmount(bal.m_watchonly_trusted));
balances_watchonly.pushKV("untrusted_pending", ValueFromAmount(bal.m_watchonly_untrusted_pending)); balances_watchonly.pushKV("untrusted_pending", ValueFromAmount(bal.m_watchonly_untrusted_pending));
balances_watchonly.pushKV("immature", ValueFromAmount(bal.m_watchonly_immature)); balances_watchonly.pushKV("immature", ValueFromAmount(bal.m_watchonly_immature));
balances.pushKV("watchonly", balances_watchonly); balances.pushKV("watchonly", std::move(balances_watchonly));
} }
AppendLastProcessedBlock(balances, wallet); AppendLastProcessedBlock(balances, wallet);
@ -724,7 +724,7 @@ RPCHelpMan listunspent()
PushParentDescriptors(*pwallet, scriptPubKey, entry); PushParentDescriptors(*pwallet, scriptPubKey, entry);
if (avoid_reuse) entry.pushKV("reused", reused); if (avoid_reuse) entry.pushKV("reused", reused);
entry.pushKV("safe", out.safe); entry.pushKV("safe", out.safe);
results.push_back(entry); results.push_back(std::move(entry));
} }
return results; return results;

6
src/wallet/rpc/spend.cpp
View file

@ -718,7 +718,7 @@ static void SetOptionsInputWeights(const UniValue& inputs, UniValue& options)
weights.push_back(input); weights.push_back(input);
} }
} }
options.pushKV("input_weights", weights); options.pushKV("input_weights", std::move(weights));
} }
RPCHelpMan fundrawtransaction() RPCHelpMan fundrawtransaction()
@ -1167,7 +1167,7 @@ static RPCHelpMan bumpfee_helper(std::string method_name)
for (const bilingual_str& error : errors) { for (const bilingual_str& error : errors) {
result_errors.push_back(error.original); result_errors.push_back(error.original);
} }
result.pushKV("errors", result_errors); result.pushKV("errors", std::move(result_errors));
return result; return result;
}, },
@ -1388,7 +1388,7 @@ RPCHelpMan sendall()
if (recipient.isStr()) { if (recipient.isStr()) {
UniValue rkvp(UniValue::VOBJ); UniValue rkvp(UniValue::VOBJ);
rkvp.pushKV(recipient.get_str(), 0); rkvp.pushKV(recipient.get_str(), 0);
recipient_key_value_pairs.push_back(rkvp); recipient_key_value_pairs.push_back(std::move(rkvp));
addresses_without_amount.insert(recipient.get_str()); addresses_without_amount.insert(recipient.get_str());
} else { } else {
recipient_key_value_pairs.push_back(recipient); recipient_key_value_pairs.push_back(recipient);

22
src/wallet/rpc/transactions.cpp
View file

@ -39,11 +39,11 @@ static void WalletTxToJSON(const CWallet& wallet, const CWalletTx& wtx, UniValue
UniValue conflicts(UniValue::VARR); UniValue conflicts(UniValue::VARR);
for (const uint256& conflict : wallet.GetTxConflicts(wtx)) for (const uint256& conflict : wallet.GetTxConflicts(wtx))
conflicts.push_back(conflict.GetHex()); conflicts.push_back(conflict.GetHex());
entry.pushKV("walletconflicts", conflicts); entry.pushKV("walletconflicts", std::move(conflicts));
UniValue mempool_conflicts(UniValue::VARR); UniValue mempool_conflicts(UniValue::VARR);
for (const Txid& mempool_conflict : wtx.mempool_conflicts) for (const Txid& mempool_conflict : wtx.mempool_conflicts)
mempool_conflicts.push_back(mempool_conflict.GetHex()); mempool_conflicts.push_back(mempool_conflict.GetHex());
entry.pushKV("mempoolconflicts", mempool_conflicts); entry.pushKV("mempoolconflicts", std::move(mempool_conflicts));
entry.pushKV("time", wtx.GetTxTime()); entry.pushKV("time", wtx.GetTxTime());
entry.pushKV("timereceived", int64_t{wtx.nTimeReceived}); entry.pushKV("timereceived", int64_t{wtx.nTimeReceived});
@ -172,8 +172,8 @@ static UniValue ListReceived(const CWallet& wallet, const UniValue& params, cons
transactions.push_back(_item.GetHex()); transactions.push_back(_item.GetHex());
} }
} }
obj.pushKV("txids", transactions); obj.pushKV("txids", std::move(transactions));
ret.push_back(obj); ret.push_back(std::move(obj));
} }
}; };
@ -195,7 +195,7 @@ static UniValue ListReceived(const CWallet& wallet, const UniValue& params, cons
obj.pushKV("amount", ValueFromAmount(nAmount)); obj.pushKV("amount", ValueFromAmount(nAmount));
obj.pushKV("confirmations", (nConf == std::numeric_limits<int>::max() ? 0 : nConf)); obj.pushKV("confirmations", (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
obj.pushKV("label", entry.first); obj.pushKV("label", entry.first);
ret.push_back(obj); ret.push_back(std::move(obj));
} }
} }
@ -353,7 +353,7 @@ static void ListTransactions(const CWallet& wallet, const CWalletTx& wtx, int nM
if (fLong) if (fLong)
WalletTxToJSON(wallet, wtx, entry); WalletTxToJSON(wallet, wtx, entry);
entry.pushKV("abandoned", wtx.isAbandoned()); entry.pushKV("abandoned", wtx.isAbandoned());
ret.push_back(entry); ret.push_back(std::move(entry));
} }
} }
@ -396,7 +396,7 @@ static void ListTransactions(const CWallet& wallet, const CWalletTx& wtx, int nM
entry.pushKV("abandoned", wtx.isAbandoned()); entry.pushKV("abandoned", wtx.isAbandoned());
if (fLong) if (fLong)
WalletTxToJSON(wallet, wtx, entry); WalletTxToJSON(wallet, wtx, entry);
ret.push_back(entry); ret.push_back(std::move(entry));
} }
} }
} }
@ -682,8 +682,8 @@ RPCHelpMan listsinceblock()
CHECK_NONFATAL(wallet.chain().findAncestorByHeight(wallet.GetLastBlockHash(), wallet.GetLastBlockHeight() + 1 - target_confirms, FoundBlock().hash(lastblock))); CHECK_NONFATAL(wallet.chain().findAncestorByHeight(wallet.GetLastBlockHash(), wallet.GetLastBlockHeight() + 1 - target_confirms, FoundBlock().hash(lastblock)));
UniValue ret(UniValue::VOBJ); UniValue ret(UniValue::VOBJ);
ret.pushKV("transactions", transactions); ret.pushKV("transactions", std::move(transactions));
if (include_removed) ret.pushKV("removed", removed); if (include_removed) ret.pushKV("removed", std::move(removed));
ret.pushKV("lastblock", lastblock.GetHex()); ret.pushKV("lastblock", lastblock.GetHex());
return ret; return ret;
@ -789,14 +789,14 @@ RPCHelpMan gettransaction()
UniValue details(UniValue::VARR); UniValue details(UniValue::VARR);
ListTransactions(*pwallet, wtx, 0, false, details, filter, /*filter_label=*/std::nullopt); ListTransactions(*pwallet, wtx, 0, false, details, filter, /*filter_label=*/std::nullopt);
entry.pushKV("details", details); entry.pushKV("details", std::move(details));
entry.pushKV("hex", EncodeHexTx(*wtx.tx)); entry.pushKV("hex", EncodeHexTx(*wtx.tx));
if (verbose) { if (verbose) {
UniValue decoded(UniValue::VOBJ); UniValue decoded(UniValue::VOBJ);
TxToUniv(*wtx.tx, /*block_hash=*/uint256(), /*entry=*/decoded, /*include_hex=*/false); TxToUniv(*wtx.tx, /*block_hash=*/uint256(), /*entry=*/decoded, /*include_hex=*/false);
entry.pushKV("decoded", decoded); entry.pushKV("decoded", std::move(decoded));
} }
AppendLastProcessedBlock(entry, *pwallet); AppendLastProcessedBlock(entry, *pwallet);

4
src/wallet/rpc/util.cpp
View file

@ -149,7 +149,7 @@ void PushParentDescriptors(const CWallet& wallet, const CScript& script_pubkey,
for (const auto& desc: wallet.GetWalletDescriptors(script_pubkey)) { for (const auto& desc: wallet.GetWalletDescriptors(script_pubkey)) {
parent_descs.push_back(desc.descriptor->ToString()); parent_descs.push_back(desc.descriptor->ToString());
} }
entry.pushKV("parent_descs", parent_descs); entry.pushKV("parent_descs", std::move(parent_descs));
} }
void HandleWalletError(const std::shared_ptr<CWallet> wallet, DatabaseStatus& status, bilingual_str& error) void HandleWalletError(const std::shared_ptr<CWallet> wallet, DatabaseStatus& status, bilingual_str& error)
@ -185,7 +185,7 @@ void AppendLastProcessedBlock(UniValue& entry, const CWallet& wallet) EXCLUSIVE_
UniValue lastprocessedblock{UniValue::VOBJ}; UniValue lastprocessedblock{UniValue::VOBJ};
lastprocessedblock.pushKV("hash", wallet.GetLastBlockHash().GetHex()); lastprocessedblock.pushKV("hash", wallet.GetLastBlockHash().GetHex());
lastprocessedblock.pushKV("height", wallet.GetLastBlockHeight()); lastprocessedblock.pushKV("height", wallet.GetLastBlockHeight());
entry.pushKV("lastprocessedblock", lastprocessedblock); entry.pushKV("lastprocessedblock", std::move(lastprocessedblock));
} }
} // namespace wallet } // namespace wallet

6
src/wallet/rpc/wallet.cpp
View file

@ -128,7 +128,7 @@ static RPCHelpMan getwalletinfo()
UniValue scanning(UniValue::VOBJ); UniValue scanning(UniValue::VOBJ);
scanning.pushKV("duration", Ticks<std::chrono::seconds>(pwallet->ScanningDuration())); scanning.pushKV("duration", Ticks<std::chrono::seconds>(pwallet->ScanningDuration()));
scanning.pushKV("progress", pwallet->ScanningProgress()); scanning.pushKV("progress", pwallet->ScanningProgress());
obj.pushKV("scanning", scanning); obj.pushKV("scanning", std::move(scanning));
} else { } else {
obj.pushKV("scanning", false); obj.pushKV("scanning", false);
} }
@ -172,11 +172,11 @@ static RPCHelpMan listwalletdir()
for (const auto& path : ListDatabases(GetWalletDir())) { for (const auto& path : ListDatabases(GetWalletDir())) {
UniValue wallet(UniValue::VOBJ); UniValue wallet(UniValue::VOBJ);
wallet.pushKV("name", path.utf8string()); wallet.pushKV("name", path.utf8string());
wallets.push_back(wallet); wallets.push_back(std::move(wallet));
} }
UniValue result(UniValue::VOBJ); UniValue result(UniValue::VOBJ);
result.pushKV("wallets", wallets); result.pushKV("wallets", std::move(wallets));
return result; return result;
}, },
}; };

4
src/wallet/test/wallet_tests.cpp
View file

@ -235,11 +235,11 @@ BOOST_FIXTURE_TEST_CASE(importmulti_rescan, TestChain100Setup)
key.pushKV("scriptPubKey", HexStr(GetScriptForRawPubKey(futureKey.GetPubKey()))); key.pushKV("scriptPubKey", HexStr(GetScriptForRawPubKey(futureKey.GetPubKey())));
key.pushKV("timestamp", newTip->GetBlockTimeMax() + TIMESTAMP_WINDOW + 1); key.pushKV("timestamp", newTip->GetBlockTimeMax() + TIMESTAMP_WINDOW + 1);
key.pushKV("internal", UniValue(true)); key.pushKV("internal", UniValue(true));
keys.push_back(key); keys.push_back(std::move(key));
JSONRPCRequest request; JSONRPCRequest request;
request.context = &context; request.context = &context;
request.params.setArray(); request.params.setArray();
request.params.push_back(keys); request.params.push_back(std::move(keys));
UniValue response = importmulti().HandleRequest(request); UniValue response = importmulti().HandleRequest(request);
BOOST_CHECK_EQUAL(response.write(), BOOST_CHECK_EQUAL(response.write(),

2
src/zmq/zmqrpc.cpp
View file

@ -47,7 +47,7 @@ static RPCHelpMan getzmqnotifications()
obj.pushKV("type", n->GetType()); obj.pushKV("type", n->GetType());
obj.pushKV("address", n->GetAddress()); obj.pushKV("address", n->GetAddress());
obj.pushKV("hwm", n->GetOutboundMessageHighWaterMark()); obj.pushKV("hwm", n->GetOutboundMessageHighWaterMark());
result.push_back(obj); result.push_back(std::move(obj));
} }
} }