35std::vector<CRecipient>
CreateRecipients(
const std::vector<std::pair<CTxDestination, CAmount>>& outputs,
const std::set<int>& subtract_fee_outputs)
37 std::vector<CRecipient> recipients;
38 for (
size_t i = 0; i < outputs.size(); ++i) {
39 const auto& [destination, amount] = outputs.at(i);
40 CRecipient recipient{destination, amount, subtract_fee_outputs.contains(i)};
41 recipients.push_back(recipient);
48 if (options.
exists(
"conf_target") || options.
exists(
"estimate_mode")) {
53 options.
pushKV(
"conf_target", conf_target);
54 options.
pushKV(
"estimate_mode", estimate_mode);
56 if (options.
exists(
"fee_rate")) {
61 options.
pushKV(
"fee_rate", fee_rate);
63 if (!options[
"conf_target"].isNull() && (options[
"estimate_mode"].isNull() || (options[
"estimate_mode"].get_str() ==
"unset"))) {
70 std::set<int> sffo_set;
71 if (sffo_instructions.
isNull())
return sffo_set;
73 for (
const auto& sffo : sffo_instructions.
getValues()) {
76 auto it = find(destinations.begin(), destinations.end(), sffo.get_str());
78 pos = it - destinations.begin();
79 }
else if (sffo.isNum()) {
80 pos = sffo.getInt<
int>();
85 if (sffo_set.contains(pos))
89 if (pos >=
int(destinations.size()))
98 bool can_anti_fee_snipe = !options.
exists(
"locktime");
100 for (
const CTxIn& tx_in : rawTx.
vin) {
105 if (can_anti_fee_snipe) {
106 LOCK(pwallet->cs_wallet);
108 DiscourageFeeSniping(rawTx, rng_fast, pwallet->chain(), pwallet->GetLastBlockHash(), pwallet->GetLastBlockHeight());
117 pwallet->FillPSBT(psbtx, complete, std::nullopt,
false,
true);
118 const auto err{pwallet->FillPSBT(psbtx, complete, std::nullopt,
true,
false)};
128 const bool psbt_opt_in{options.
exists(
"psbt") && options[
"psbt"].
get_bool()};
129 bool add_to_wallet{options.
exists(
"add_to_wallet") ? options[
"add_to_wallet"].
get_bool() :
true};
130 if (psbt_opt_in || !complete || !add_to_wallet) {
140 result.
pushKV(
"txid", tx->GetHash().GetHex());
141 if (add_to_wallet && !psbt_opt_in) {
142 pwallet->CommitTransaction(tx, {}, {});
144 result.
pushKV(
"hex", hex);
147 result.
pushKV(
"complete", complete);
154 if (options.
exists(
"feeRate")) {
157 if (options.
exists(
"changeAddress")) {
160 if (options.
exists(
"changePosition")) {
163 if (options.
exists(
"lockUnspents")) {
166 if (options.
exists(
"subtractFeeFromOutputs")) {
190 wallet.CommitTransaction(tx, std::move(map_value), {});
193 entry.
pushKV(
"txid", tx->GetHash().GetHex());
197 return tx->GetHash().GetHex();
217 if (!conf_target.
isNull()) {
218 throw JSONRPCError(
RPC_INVALID_PARAMETER,
"Cannot specify both conf_target and fee_rate. Please provide either a confirmation target in blocks for automatic fee estimation, or an explicit fee rate.");
220 if (!estimate_mode.
isNull() && estimate_mode.
get_str() !=
"unset") {
233 if (!conf_target.
isNull()) {
242 "Send an amount to a given address." +
248 "This is not part of the transaction, just kept in your wallet."},
250 "to which you're sending the transaction. This is not part of the \n"
251 "transaction, just kept in your wallet."},
253 "The recipient will receive less bitcoins than you enter in the amount field."},
257 +
FeeModesDetail(std::string(
"economical mode is used if the transaction is replaceable;\notherwise, conservative mode is used"))},
258 {
"avoid_reuse",
RPCArg::Type::BOOL,
RPCArg::Default{
true},
"(only available if avoid_reuse wallet flag is set) Avoid spending from dirty addresses; addresses are considered\n"
259 "dirty if they have previously been used in a transaction. If true, this also activates avoidpartialspends, grouping outputs by their addresses."},
264 RPCResult{
"if verbose is not set or set to false",
278 "\nSend 0.1 BTC with a confirmation target of 6 blocks in economical fee estimate mode using positional arguments\n"
280 "\nSend 0.1 BTC with a fee rate of 1.1 " +
CURRENCY_ATOM +
"/vB, subtract fee from amount, BIP125-replaceable, using positional arguments\n"
282 "\nSend 0.2 BTC with a confirmation target of 6 blocks in economical fee estimate mode using named arguments\n"
284 "\nSend 0.5 BTC with a fee rate of 25 " +
CURRENCY_ATOM +
"/vB using named arguments\n"
286 +
HelpExampleCli(
"-named sendtoaddress",
"address=\"" +
EXAMPLE_ADDRESS[0] +
"\" amount=0.5 fee_rate=25 subtractfeefromamount=false replaceable=true avoid_reuse=true comment=\"2 pizzas\" comment_to=\"jeremy\" verbose=true")
295 pwallet->BlockUntilSyncedToCurrentChain();
297 LOCK(pwallet->cs_wallet);
301 if (!request.params[2].isNull() && !request.params[2].get_str().empty())
302 mapValue[
"comment"] = request.params[2].get_str();
303 if (!request.params[3].isNull() && !request.params[3].get_str().empty())
304 mapValue[
"to"] = request.params[3].get_str();
307 if (!request.params[5].isNull()) {
315 SetFeeEstimateMode(*pwallet, coin_control, request.params[6], request.params[7], request.params[9],
false);
320 const std::string address = request.params[0].get_str();
321 address_amounts.
pushKV(address, request.params[1]);
323 std::set<int> sffo_set;
324 if (!request.params[4].isNull() && request.params[4].get_bool()) {
329 const bool verbose{request.params[10].isNull() ? false : request.params[10].get_bool()};
331 return SendMoney(*pwallet, coin_control, recipients, mapValue, verbose);
339 "Send multiple times. Amounts are double-precision floating point numbers." +
354 "The fee will be equally deducted from the amount of each selected address.\n"
355 "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
356 "If no addresses are specified here, the sender pays the fee.",
364 +
FeeModesDetail(std::string(
"economical mode is used if the transaction is replaceable;\notherwise, conservative mode is used"))},
369 RPCResult{
"if verbose is not set or set to false",
371 "the number of addresses."
377 "the number of addresses."},
383 "\nSend two amounts to two different addresses:\n"
385 "\nSend two amounts to two different addresses setting the confirmation and comment:\n"
387 "\nSend two amounts to two different addresses, subtract fee from amount:\n"
389 "\nAs a JSON-RPC call\n"
399 pwallet->BlockUntilSyncedToCurrentChain();
401 LOCK(pwallet->cs_wallet);
403 if (!request.params[0].isNull() && !request.params[0].get_str().empty()) {
409 if (!request.params[3].isNull() && !request.params[3].get_str().empty())
410 mapValue[
"comment"] = request.params[3].
get_str();
413 if (!request.params[5].isNull()) {
417 SetFeeEstimateMode(*pwallet, coin_control, request.params[6], request.params[7], request.params[8],
false);
423 const bool verbose{request.params[9].isNull() ? false : request.params[9].get_bool()};
425 return SendMoney(*pwallet, coin_control, recipients, std::move(mapValue), verbose);
434 "(DEPRECATED) Set the transaction fee rate in " +
CURRENCY_UNIT +
"/kvB for this wallet. Overrides the global -paytxfee command line parameter.\n"
435 "Can be deactivated by passing 0 as the fee. In that case automatic fee selection will be used by default.\n",
451 LOCK(pwallet->cs_wallet);
453 if (!pwallet->chain().rpcEnableDeprecated(
"settxfee")) {
455 "\nTo use settxfee restart bitcoind with -deprecatedrpc=settxfee.");
459 CFeeRate tx_fee_rate(nAmount, 1000);
460 CFeeRate max_tx_fee_rate(pwallet->m_default_max_tx_fee, 1000);
463 }
else if (tx_fee_rate < pwallet->chain().relayMinFee()) {
465 }
else if (tx_fee_rate < pwallet->m_min_fee) {
467 }
else if (tx_fee_rate > max_tx_fee_rate) {
471 pwallet->m_pay_tx_fee = tx_fee_rate;
479static std::vector<RPCArg>
FundTxDoc(
bool solving_data =
true)
481 std::vector<RPCArg>
args = {
487 "Allows this transaction to be replaced by a transaction with higher fees"
492 "Used for fee estimation during coin selection.",
525 wallet.BlockUntilSyncedToCurrentChain();
527 std::optional<unsigned int> change_position;
528 bool lockUnspents =
false;
565 if (options.
exists(
"add_inputs")) {
569 if (options.
exists(
"changeAddress") || options.
exists(
"change_address")) {
570 const std::string change_address_str = (options.
exists(
"change_address") ? options[
"change_address"] : options[
"changeAddress"]).get_str();
580 if (options.
exists(
"changePosition") || options.
exists(
"change_position")) {
581 int pos = (options.
exists(
"change_position") ? options[
"change_position"] : options[
"changePosition"]).getInt<int>();
582 if (pos < 0 || (
unsigned int)pos > recipients.size()) {
585 change_position = (
unsigned int)pos;
588 if (options.
exists(
"change_type")) {
589 if (options.
exists(
"changeAddress") || options.
exists(
"change_address")) {
592 if (std::optional<OutputType> parsed =
ParseOutputType(options[
"change_type"].get_str())) {
599 if (options.
exists(
"lockUnspents") || options.
exists(
"lock_unspents")) {
600 lockUnspents = (options.
exists(
"lock_unspents") ? options[
"lock_unspents"] : options[
"lockUnspents"]).get_bool();
603 if (options.
exists(
"include_unsafe")) {
607 if (options.
exists(
"feeRate")) {
608 if (options.
exists(
"fee_rate")) {
611 if (options.
exists(
"conf_target")) {
612 throw JSONRPCError(
RPC_INVALID_PARAMETER,
"Cannot specify both conf_target and feeRate. Please provide either a confirmation target in blocks for automatic fee estimation, or an explicit fee rate.");
614 if (options.
exists(
"estimate_mode")) {
621 if (options.
exists(
"replaceable")) {
625 if (options.
exists(
"minconf")) {
633 if (options.
exists(
"maxconf")) {
640 SetFeeEstimateMode(
wallet, coinControl, options[
"conf_target"], options[
"estimate_mode"], options[
"fee_rate"], override_min_fee);
644 if (options.
exists(
"solving_data")) {
646 if (solving_data.
exists(
"pubkeys")) {
647 for (
const UniValue& pk_univ : solving_data[
"pubkeys"].get_array().getValues()) {
656 if (solving_data.
exists(
"scripts")) {
657 for (
const UniValue& script_univ : solving_data[
"scripts"].get_array().getValues()) {
658 const std::string& script_str = script_univ.get_str();
659 if (!
IsHex(script_str)) {
662 std::vector<unsigned char> script_data(
ParseHex(script_str));
663 const CScript script(script_data.begin(), script_data.end());
668 if (solving_data.
exists(
"descriptors")) {
669 for (
const UniValue& desc_univ : solving_data[
"descriptors"].get_array().getValues()) {
670 const std::string& desc_str = desc_univ.get_str();
673 std::vector<CScript> scripts_temp;
674 auto descs =
Parse(desc_str, desc_out, error,
true);
678 for (
auto& desc : descs) {
679 desc->Expand(0, desc_out, scripts_temp, desc_out);
686 if (options.
exists(
"input_weights")) {
687 for (
const UniValue& input : options[
"input_weights"].get_array().getValues()) {
691 if (!vout_v.
isNum()) {
694 int vout = vout_v.
getInt<
int>();
700 if (!weight_v.
isNum()) {
703 int64_t weight = weight_v.
getInt<int64_t>();
706 if (weight < min_input_weight) {
707 throw JSONRPCError(
RPC_INVALID_PARAMETER,
"Invalid parameter, weight cannot be less than 165 (41 bytes (size of outpoint + sequence + empty scriptSig) * 4 (witness scaling factor)) + 1 (empty witness)");
717 if (options.
exists(
"max_tx_weight")) {
727 if (recipients.empty())
739 if (options.
exists(
"input_weights")) {
742 if (inputs.
size() == 0) {
747 if (input.exists(
"weight")) {
751 options.
pushKV(
"input_weights", std::move(weights));
757 "fundrawtransaction",
758 "If the transaction has no inputs, they will be automatically selected to meet its out value.\n"
759 "It will add at most one change output to the outputs.\n"
760 "No existing outputs will be modified unless \"subtractFeeFromOutputs\" is specified.\n"
761 "Note that inputs which were signed may need to be resigned after completion since in/outputs have been added.\n"
762 "The inputs added will not be signed, use signrawtransactionwithkey\n"
763 "or signrawtransactionwithwallet for that.\n"
764 "All existing inputs must either have their previous output transaction be in the wallet\n"
765 "or be in the UTXO set. Solving data must be provided for non-wallet inputs.\n"
766 "Note that all inputs selected must be of standard form and P2SH scripts must be\n"
767 "in the wallet using importdescriptors (to calculate fees).\n"
768 "You can see whether this is the case by checking the \"solvable\" field in the listunspent output.\n"
769 "Note that if specifying an exact fee rate, the resulting transaction may have a higher fee rate\n"
770 "if the transaction has unconfirmed inputs. This is because the wallet will attempt to make the\n"
771 "entire package have the given fee rate, not the resulting transaction.\n",
775 Cat<std::vector<RPCArg>>(
778 {
"include_unsafe",
RPCArg::Type::BOOL,
RPCArg::Default{
false},
"Include inputs that are not safe to spend (unconfirmed transactions from outside keys and unconfirmed replacement transactions).\n"
779 "Warning: the resulting transaction may become invalid if one of the unsafe inputs disappears.\n"
780 "If that happens, you will need to fund the transaction with different inputs and republish it."},
791 "The fee will be equally deducted from the amount of each specified output.\n"
792 "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
793 "If no outputs are specified here, the sender pays the fee.",
805 "including the weight of the outpoint and sequence number. "
806 "Note that serialized signature sizes are not guaranteed to be consistent, "
807 "so the maximum DER signatures size of 73 bytes should be used when considering ECDSA signatures."
808 "Remember to convert serialized sizes to weight units when necessary."},
814 "Transaction building will fail if this can not be satisfied."},
819 .oneline_description =
"options",
822 "If iswitness is not present, heuristic tests will be used in decoding.\n"
823 "If true, only witness deserialization will be tried.\n"
824 "If false, only non-witness deserialization will be tried.\n"
825 "This boolean should reflect whether the transaction has inputs\n"
826 "(e.g. fully valid, or on-chain transactions), if known by the caller."
838 "\nCreate a transaction with no inputs\n"
839 +
HelpExampleCli(
"createrawtransaction",
"\"[]\" \"{\\\"myaddress\\\":0.01}\"") +
840 "\nAdd sufficient unsigned inputs to meet the output value\n"
842 "\nSign the transaction\n"
843 +
HelpExampleCli(
"signrawtransactionwithwallet",
"\"fundedtransactionhex\"") +
844 "\nSend the transaction\n"
845 +
HelpExampleCli(
"sendrawtransaction",
"\"signedtransactionhex\"")
854 bool try_witness = request.params[2].isNull() ? true : request.params[2].get_bool();
855 bool try_no_witness = request.params[2].isNull() ? true : !request.params[2].get_bool();
856 if (!
DecodeHexTx(tx, request.params[0].get_str(), try_no_witness, try_witness)) {
859 UniValue options = request.params[1];
860 std::vector<std::pair<CTxDestination, CAmount>> destinations;
861 for (
const auto& tx_out : tx.
vout) {
864 destinations.emplace_back(dest, tx_out.nValue);
866 std::vector<std::string> dummy(destinations.size(),
"dummy");
877 auto txr =
FundTransaction(*pwallet, tx, recipients, options, coin_control,
true);
882 result.
pushKV(
"changepos", txr.change_pos ? (
int)*txr.change_pos : -1);
892 "signrawtransactionwithwallet",
893 "Sign inputs for raw transaction (serialized, hex-encoded).\n"
894 "The second optional argument (may be null) is an array of previous transaction outputs that\n"
895 "this transaction depends on but may not yet be in the block chain." +
918 " \"ALL|ANYONECANPAY\"\n"
919 " \"NONE|ANYONECANPAY\"\n"
920 " \"SINGLE|ANYONECANPAY\""},
954 if (!
DecodeHexTx(mtx, request.params[0].get_str())) {
959 LOCK(pwallet->cs_wallet);
963 std::map<COutPoint, Coin> coins;
967 pwallet->chain().findCoins(coins);
978 std::map<int, bilingual_str> input_errors;
980 bool complete = pwallet->SignTransaction(mtx, coins, *nHashType, input_errors);
997 "the value (float or string) is the amount in " +
CURRENCY_UNIT +
""},
1010 const bool want_psbt = method_name ==
"psbtbumpfee";
1014 "Bumps the fee of a transaction T, replacing it with a new transaction B.\n"
1015 + std::string(want_psbt ?
"Returns a PSBT instead of creating and signing a new transaction.\n" :
"") +
1016 "A transaction with the given txid must be in the wallet.\n"
1017 "The command will pay the additional fee by reducing change outputs or adding inputs when necessary.\n"
1018 "It may add a new change output if one does not already exist.\n"
1019 "All inputs in the original transaction will be included in the replacement transaction.\n"
1020 "The command will fail if the wallet or mempool contains a transaction that spends one of T's outputs.\n"
1021 "By default, the new fee will be calculated automatically using the estimatesmartfee RPC.\n"
1022 "The user can specify a confirmation target for estimatesmartfee.\n"
1023 "Alternatively, the user can specify a fee rate in " +
CURRENCY_ATOM +
"/vB for the new transaction.\n"
1024 "At a minimum, the new fee rate must be high enough to pay an additional new relay fee (incrementalfee\n"
1025 "returned by getnetworkinfo) to enter the node's mempool.\n"
1026 "* WARNING: before version 0.21, fee_rate was in " +
CURRENCY_UNIT +
"/kvB. As of 0.21, fee_rate is in " +
CURRENCY_ATOM +
"/vB. *\n",
1033 "\nSpecify a fee rate in " +
CURRENCY_ATOM +
"/vB instead of relying on the built-in fee estimator.\n"
1034 "Must be at least " + incremental_fee +
" higher than the current transaction fee rate.\n"
1035 "WARNING: before version 0.21, fee_rate was in " +
CURRENCY_UNIT +
"/kvB. As of 0.21, fee_rate is in " +
CURRENCY_ATOM +
"/vB.\n"},
1037 "Whether the new transaction should be\n"
1038 "marked bip-125 replaceable. If true, the sequence numbers in the transaction will\n"
1039 "be set to 0xfffffffd. If false, any input sequence numbers in the\n"
1040 "transaction will be set to 0xfffffffe\n"
1041 "so the new transaction will not be explicitly bip-125 replaceable (though it may\n"
1042 "still be replaceable in practice, for example if it has unconfirmed ancestors which\n"
1043 "are replaceable).\n"},
1045 +
FeeModesDetail(std::string(
"economical mode is used if the transaction is replaceable;\notherwise, conservative mode is used"))},
1047 "Each key may only appear once, i.e. there can only be one 'data' output, and no address may be duplicated.\n"
1048 "At least one output of either type must be specified.\n"
1049 "Cannot be provided if 'original_change_index' is specified.",
1052 {
"original_change_index",
RPCArg::Type::NUM,
RPCArg::DefaultHint{
"not set, detect change automatically"},
"The 0-based index of the change output on the original transaction. "
1053 "The indicated output will be recycled into the new change output on the bumped transaction. "
1054 "The remainder after paying the recipients and fees will be sent to the output script of the "
1055 "original change output. The change output’s amount can increase if bumping the transaction "
1056 "adds new inputs, otherwise it will decrease. Cannot be used in combination with the 'outputs' option."},
1063 std::vector<RPCResult>{{
RPCResult::Type::STR,
"psbt",
"The base64-encoded unsigned PSBT of the new transaction."}} :
1075 "\nBump the fee, get the new transaction\'s " + std::string(want_psbt ?
"psbt" :
"txid") +
"\n" +
1084 throw JSONRPCError(
RPC_WALLET_ERROR,
"bumpfee is not available with wallets that have private keys disabled. Use psbtbumpfee instead.");
1092 std::vector<CTxOut> outputs;
1094 std::optional<uint32_t> original_change_index;
1096 if (!request.params[1].isNull()) {
1097 UniValue options = request.params[1];
1110 if (options.
exists(
"confTarget") && options.
exists(
"conf_target")) {
1114 auto conf_target = options.
exists(
"confTarget") ? options[
"confTarget"] : options[
"conf_target"];
1116 if (options.
exists(
"replaceable")) {
1119 SetFeeEstimateMode(*pwallet, coin_control, conf_target, options[
"estimate_mode"], options[
"fee_rate"],
false);
1122 if (!options[
"outputs"].isNull()) {
1123 if (options[
"outputs"].isArray() && options[
"outputs"].empty()) {
1128 outputs = tempTx.
vout;
1131 if (options.
exists(
"original_change_index")) {
1132 original_change_index = options[
"original_change_index"].
getInt<uint32_t>();
1138 pwallet->BlockUntilSyncedToCurrentChain();
1140 LOCK(pwallet->cs_wallet);
1145 std::vector<bilingual_str> errors;
1192 bool complete =
false;
1193 const auto err{pwallet->FillPSBT(psbtx, complete, std::nullopt,
false,
true)};
1205 result_errors.
push_back(error.original);
1207 result.
pushKV(
"errors", std::move(result_errors));
1221 "EXPERIMENTAL warning: this call may be changed in future releases.\n"
1222 "\nSend a transaction.\n",
1225 "Each key may only appear once, i.e. there can only be one 'data' output, and no address may be duplicated.\n"
1226 "At least one output of either type must be specified.\n"
1227 "For convenience, a dictionary, which holds the key-value pairs directly, is also accepted.",
1232 +
FeeModesDetail(std::string(
"economical mode is used if the transaction is replaceable;\notherwise, conservative mode is used"))},
1235 Cat<std::vector<RPCArg>>(
1237 {
"add_inputs",
RPCArg::Type::BOOL,
RPCArg::DefaultHint{
"false when \"inputs\" are specified, true otherwise"},
"Automatically include coins from the wallet to cover the target amount.\n"},
1238 {
"include_unsafe",
RPCArg::Type::BOOL,
RPCArg::Default{
false},
"Include inputs that are not safe to spend (unconfirmed transactions from outside keys and unconfirmed replacement transactions).\n"
1239 "Warning: the resulting transaction may become invalid if one of the unsafe inputs disappears.\n"
1240 "If that happens, you will need to fund the transaction with different inputs and republish it."},
1243 {
"add_to_wallet",
RPCArg::Type::BOOL,
RPCArg::Default{
true},
"When false, returns a serialized transaction which will not be added to the wallet or broadcast"},
1256 "including the weight of the outpoint and sequence number. "
1257 "Note that signature sizes are not guaranteed to be consistent, "
1258 "so the maximum DER signatures size of 73 bytes should be used when considering ECDSA signatures."
1259 "Remember to convert serialized sizes to weight units when necessary."},
1267 "The fee will be equally deducted from the amount of each specified output.\n"
1268 "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
1269 "If no outputs are specified here, the sender pays the fee.",
1275 "Transaction building will fail if this can not be satisfied."},
1285 {
RPCResult::Type::STR_HEX,
"txid",
true,
"The transaction id for the send. Only 1 transaction is created regardless of the number of addresses."},
1286 {
RPCResult::Type::STR_HEX,
"hex",
true,
"If add_to_wallet is false, the hex-encoded raw transaction with signature(s)"},
1287 {
RPCResult::Type::STR,
"psbt",
true,
"If more signatures are needed, or if add_to_wallet is false, the base64-encoded (partially) signed transaction"}
1291 "\nSend 0.1 BTC with a confirmation target of 6 blocks in economical fee estimate mode\n"
1293 "Send 0.2 BTC with a fee rate of 1.1 " +
CURRENCY_ATOM +
"/vB using positional arguments\n"
1295 "Send 0.2 BTC with a fee rate of 1 " +
CURRENCY_ATOM +
"/vB using the options argument\n"
1297 "Send 0.3 BTC with a fee rate of 25 " +
CURRENCY_ATOM +
"/vB using named arguments\n"
1299 "Create a transaction that should confirm the next block, with a specific input, and return result without adding to wallet or broadcasting to the network\n"
1300 +
HelpExampleCli(
"send",
"'{\"" +
EXAMPLE_ADDRESS[0] +
"\": 0.1}' 1 economical '{\"add_to_wallet\": false, \"inputs\": [{\"txid\":\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\", \"vout\":1}]}'")
1312 bool rbf{options.exists(
"replaceable") ? options[
"replaceable"].get_bool() : pwallet->m_signal_rbf};
1320 coin_control.
m_version = self.
Arg<uint32_t>(
"version");
1325 if (options.exists(
"max_tx_weight")) {
1326 coin_control.
m_max_tx_weight = options[
"max_tx_weight"].getInt<
int>();
1333 auto txr =
FundTransaction(*pwallet, rawTx, recipients, options, coin_control,
false);
1344 "EXPERIMENTAL warning: this call may be changed in future releases.\n"
1345 "\nSpend the value of all (or specific) confirmed UTXOs and unconfirmed change in the wallet to one or more recipients.\n"
1346 "Unconfirmed inbound UTXOs and locked UTXOs will not be spent. Sendall will respect the avoid_reuse wallet flag.\n"
1347 "If your wallet contains many small inputs, either because it received tiny payments or as a result of accumulating change, consider using `send_max` to exclude inputs that are worth less than the fees needed to spend them.\n",
1350 "Optionally some recipients can be specified with an amount to perform payments, but at least one address must appear without a specified amount.\n",
1362 +
FeeModesDetail(std::string(
"economical mode is used if the transaction is replaceable;\notherwise, conservative mode is used"))},
1366 Cat<std::vector<RPCArg>>(
1385 {
"send_max",
RPCArg::Type::BOOL,
RPCArg::Default{
false},
"When true, only use UTXOs that can pay for their own fees to maximize the output amount. When 'false' (default), no UTXO is left behind. send_max is incompatible with providing specific inputs."},
1399 {
RPCResult::Type::STR_HEX,
"txid",
true,
"The transaction id for the send. Only 1 transaction is created regardless of the number of addresses."},
1400 {
RPCResult::Type::STR_HEX,
"hex",
true,
"If add_to_wallet is false, the hex-encoded raw transaction with signature(s)"},
1401 {
RPCResult::Type::STR,
"psbt",
true,
"If more signatures are needed, or if add_to_wallet is false, the base64-encoded (partially) signed transaction"}
1405 "\nSpend all UTXOs from the wallet with a fee rate of 1Â " +
CURRENCY_ATOM +
"/vB using named arguments\n"
1407 "Spend all UTXOs with a fee rate of 1.1 " +
CURRENCY_ATOM +
"/vB using positional arguments\n"
1409 "Spend all UTXOs split into equal amounts to two addresses with a fee rate of 1.5 " +
CURRENCY_ATOM +
"/vB using the options argument\n"
1411 "Leave dust UTXOs in wallet, spend only UTXOs with positive effective value with a fee rate of 10 " +
CURRENCY_ATOM +
"/vB using the options argument\n"
1413 "Spend all UTXOs with a fee rate of 1.3 " +
CURRENCY_ATOM +
"/vB using named arguments and sending a 0.25 " +
CURRENCY_UNIT +
" to another recipient\n"
1422 pwallet->BlockUntilSyncedToCurrentChain();
1429 std::set<std::string> addresses_without_amount;
1431 const UniValue& recipients{request.params[0]};
1432 for (
unsigned int i = 0; i < recipients.size(); ++i) {
1433 const UniValue& recipient{recipients[i]};
1434 if (recipient.isStr()) {
1436 rkvp.
pushKV(recipient.get_str(), 0);
1437 recipient_key_value_pairs.
push_back(std::move(rkvp));
1438 addresses_without_amount.insert(recipient.get_str());
1440 recipient_key_value_pairs.
push_back(recipient);
1444 if (addresses_without_amount.size() == 0) {
1450 SetFeeEstimateMode(*pwallet, coin_control, options[
"conf_target"], options[
"estimate_mode"], options[
"fee_rate"],
false);
1452 if (options.exists(
"minconf")) {
1453 if (options[
"minconf"].getInt<int>() < 0)
1458 coin_control.
m_min_depth = options[
"minconf"].getInt<
int>();
1461 if (options.exists(
"maxconf")) {
1462 coin_control.
m_max_depth = options[
"maxconf"].getInt<
int>();
1469 if (options.exists(
"version")) {
1470 coin_control.
m_version = options[
"version"].getInt<
int>();
1479 const bool rbf{options.exists(
"replaceable") ? options[
"replaceable"].get_bool() : pwallet->m_signal_rbf};
1494 LOCK(pwallet->cs_wallet);
1497 bool send_max{options.exists(
"send_max") ? options[
"send_max"].get_bool() :
false};
1498 if (options.exists(
"inputs") && options.exists(
"send_max")) {
1500 }
else if (options.exists(
"inputs") && (options.exists(
"minconf") || options.exists(
"maxconf"))) {
1502 }
else if (options.exists(
"inputs")) {
1503 for (
const CTxIn& input : rawTx.vin) {
1504 if (pwallet->IsSpent(input.
prevout)) {
1508 if (!tx || input.
prevout.
n >= tx->tx->vout.size() || !pwallet->IsMine(tx->tx->vout[input.
prevout.
n])) {
1511 if (pwallet->GetTxDepthInMainChain(*tx) == 0) {
1518 total_input_value += tx->tx->vout[input.
prevout.
n].nValue;
1525 if (send_max && fee_rate.GetFee(output.input_bytes) > output.txout.nValue) {
1533 rawTx.vin.push_back(input);
1534 total_input_value += output.txout.nValue;
1538 std::vector<COutPoint> outpoints_spent;
1539 outpoints_spent.reserve(rawTx.vin.size());
1541 for (
const CTxIn& tx_in : rawTx.vin) {
1542 outpoints_spent.push_back(tx_in.
prevout);
1547 const CAmount fee_from_size{fee_rate.GetFee(tx_size.vsize)};
1548 const std::optional<CAmount> total_bump_fees{pwallet->chain().calculateCombinedBumpFee(outpoints_spent, fee_rate)};
1549 CAmount effective_value = total_input_value - fee_from_size - total_bump_fees.value_or(0);
1551 if (fee_from_size > pwallet->m_default_max_tx_fee) {
1555 if (effective_value <= 0) {
1568 CAmount output_amounts_claimed{0};
1570 output_amounts_claimed +=
out.nValue;
1573 if (output_amounts_claimed > total_input_value) {
1577 const CAmount remainder{effective_value - output_amounts_claimed};
1578 if (remainder < 0) {
1582 const CAmount per_output_without_amount{remainder / (long)addresses_without_amount.size()};
1584 bool gave_remaining_to_first{
false};
1589 if (addresses_without_amount.count(addr) > 0) {
1590 out.nValue = per_output_without_amount;
1591 if (!gave_remaining_to_first) {
1592 out.nValue += remainder % addresses_without_amount.size();
1593 gave_remaining_to_first =
true;
1595 if (
IsDust(
out, pwallet->chain().relayDustFee())) {
1600 if (
IsDust(
out, pwallet->chain().relayDustFee())) {
1607 const bool lock_unspents{options.exists(
"lock_unspents") ? options[
"lock_unspents"].get_bool() :
false};
1608 if (lock_unspents) {
1609 for (
const CTxIn& txin : rawTx.vin) {
1610 pwallet->LockCoin(txin.
prevout,
false);
1622 "walletprocesspsbt",
1623 "Update a PSBT with input information from our wallet and then sign inputs\n"
1624 "that we can sign for." +
1629 {
"sighashtype",
RPCArg::Type::STR,
RPCArg::Default{
"DEFAULT for Taproot, ALL otherwise"},
"The signature hash type to sign with if not specified by the PSBT. Must be one of\n"
1634 " \"ALL|ANYONECANPAY\"\n"
1635 " \"NONE|ANYONECANPAY\"\n"
1636 " \"SINGLE|ANYONECANPAY\""},
1659 wallet.BlockUntilSyncedToCurrentChain();
1672 bool sign = request.params[1].isNull() ? true : request.params[1].get_bool();
1673 bool bip32derivs = request.params[3].isNull() ? true : request.params[3].get_bool();
1674 bool finalize = request.params[4].isNull() ? true : request.params[4].get_bool();
1675 bool complete =
true;
1679 const auto err{
wallet.FillPSBT(psbtx, complete, nHashType,
sign, bip32derivs,
nullptr, finalize)};
1688 result.
pushKV(
"complete", complete);
1706 "walletcreatefundedpsbt",
1707 "Creates and funds a transaction in the Partially Signed Transaction format.\n"
1708 "Implements the Creator and Updater roles.\n"
1709 "All existing inputs must either have their previous output transaction be in the wallet\n"
1710 "or be in the UTXO set. Solving data must be provided for non-wallet inputs.\n",
1720 "including the weight of the outpoint and sequence number. "
1721 "Note that signature sizes are not guaranteed to be consistent, "
1722 "so the maximum DER signatures size of 73 bytes should be used when considering ECDSA signatures."
1723 "Remember to convert serialized sizes to weight units when necessary."},
1729 "Each key may only appear once, i.e. there can only be one 'data' output, and no address may be duplicated.\n"
1730 "At least one output of either type must be specified.\n"
1731 "For compatibility reasons, a dictionary, which holds the key-value pairs directly, is also\n"
1732 "accepted as second parameter.",
1737 Cat<std::vector<RPCArg>>(
1739 {
"add_inputs",
RPCArg::Type::BOOL,
RPCArg::DefaultHint{
"false when \"inputs\" are specified, true otherwise"},
"Automatically include coins from the wallet to cover the target amount.\n"},
1740 {
"include_unsafe",
RPCArg::Type::BOOL,
RPCArg::Default{
false},
"Include inputs that are not safe to spend (unconfirmed transactions from outside keys and unconfirmed replacement transactions).\n"
1741 "Warning: the resulting transaction may become invalid if one of the unsafe inputs disappears.\n"
1742 "If that happens, you will need to fund the transaction with different inputs and republish it."},
1753 "The fee will be equally deducted from the amount of each specified output.\n"
1754 "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
1755 "If no outputs are specified here, the sender pays the fee.",
1761 "Transaction building will fail if this can not be satisfied."},
1777 "\nCreate a PSBT with automatically picked inputs that sends 0.5 BTC to an address and has a fee rate of 2 sat/vB:\n"
1778 +
HelpExampleCli(
"walletcreatefundedpsbt",
"\"[]\" \"[{\\\"" +
EXAMPLE_ADDRESS[0] +
"\\\":0.5}]\" 0 \"{\\\"add_inputs\\\":true,\\\"fee_rate\\\":2}\"")
1779 +
"\nCreate the same PSBT as the above one instead using named arguments:\n"
1790 wallet.BlockUntilSyncedToCurrentChain();
1795 coin_control.
m_version = self.
Arg<uint32_t>(
"version");
1797 const UniValue &replaceable_arg = options[
"replaceable"];
1798 const bool rbf{replaceable_arg.
isNull() ?
wallet.m_signal_rbf : replaceable_arg.get_bool()};
1819 bool bip32derivs = request.params[4].isNull() ? true : request.params[4].get_bool();
1820 bool complete =
true;
1821 const auto err{
wallet.FillPSBT(psbtx, complete, std::nullopt,
false, bip32derivs)};
1833 result.
pushKV(
"changepos", txr.change_pos ? (
int)*txr.change_pos : -1);
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a scriptPubKey for the destination.
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination corresponds to one with an address.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
int64_t CAmount
Amount in satoshis (Can be negative)
static CAmount AmountFromValue(const UniValue &value)
#define CHECK_NONFATAL(condition)
Identity function.
Fee rate in satoshis per virtualbyte: CAmount / vB the feerate is represented internally as FeeFrac.
std::string ToString(const FeeEstimateMode &fee_estimate_mode=FeeEstimateMode::BTC_KVB) const
An outpoint - a combination of a transaction hash and an index n into its vout.
An encapsulated public key.
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Serialized script, used inside transaction inputs and outputs.
A reference to a CScript: the Hash160 of its serialization.
The basic transaction that is broadcasted on the network and contained in blocks.
An input of a transaction.
static const uint32_t MAX_SEQUENCE_NONFINAL
This is the maximum sequence number that enables both nLockTime and OP_CHECKLOCKTIMEVERIFY (BIP 65).
static const uint32_t SEQUENCE_FINAL
Setting nSequence to this value for every input in a transaction disables nLockTime/IsFinalTx().
An output of a transaction.
Double ended buffer combining vector and stream-like interfaces.
auto Arg(std::string_view key) const
Helper to get a required or default-valued request argument.
void push_back(UniValue val)
const std::string & get_str() const
const UniValue & find_value(std::string_view key) const
const UniValue & get_obj() const
const std::vector< UniValue > & getValues() const
const std::vector< std::string > & getKeys() const
bool exists(const std::string &key) const
void pushKV(std::string key, UniValue val)
std::string ToString() const
std::string GetHex() const
static transaction_identifier FromUint256(const uint256 &id)
FeeEstimateMode m_fee_mode
Fee estimation mode to control arguments to estimateSmartFee.
std::optional< bool > m_signal_bip125_rbf
Override the wallet's m_signal_rbf if set.
std::optional< unsigned int > m_confirm_target
Override the default confirmation target if set.
std::optional< int > m_max_tx_weight
Caps weight of resulting tx.
std::optional< OutputType > m_change_type
Override the default change type if set, ignored if destChange is set.
bool m_avoid_address_reuse
Forbids inclusion of dirty (previously used) addresses.
int m_min_depth
Minimum chain depth value for coin availability.
bool m_allow_other_inputs
If true, the selection process can add extra unselected inputs from the wallet while requires all sel...
int m_max_depth
Maximum chain depth value for coin availability.
bool fOverrideFeeRate
Override automatic min/max checks on fee, m_feerate must be set if true.
void SetInputWeight(const COutPoint &outpoint, int64_t weight)
Set an input's weight.
std::optional< CFeeRate > m_feerate
Override the wallet's m_pay_tx_fee if set.
bool m_include_unsafe_inputs
If false, only safe inputs will be used.
bool m_avoid_partial_spends
Avoid partial use of funds sent to a given address.
uint32_t m_version
Version.
FlatSigningProvider m_external_provider
SigningProvider that has pubkeys and scripts to do spend size estimation for external inputs.
CTxDestination destChange
Custom change destination, if not set an address is generated.
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
A transaction with a bunch of additional info that only the owner cares about.
static UniValue Parse(std::string_view raw)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
static int64_t GetTransactionInputWeight(const CTxIn &txin)
std::string EncodeHexTx(const CTransaction &tx)
UniValue ValueFromAmount(const CAmount amount)
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
const std::string CURRENCY_ATOM
const std::string CURRENCY_UNIT
@ SAT_VB
Use sat/vB fee rate unit.
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
@ SIGHASH_DEFAULT
Taproot only; implied when sighash byte is missing, and equivalent to SIGHASH_ALL.
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
std::string EncodeDestination(const CTxDestination &dest)
is a home for simple string functions returning descriptive messages that are used in RPC and GUI int...
static int sign(const secp256k1_context *ctx, struct signer_secrets *signer_secrets, struct signer *signer, const secp256k1_musig_keyagg_cache *cache, const unsigned char *msg32, unsigned char *sig64)
bool FeeModeFromString(const std::string &mode_string, FeeEstimateMode &fee_estimate_mode)
std::string FeeModesDetail(std::string default_info)
bilingual_str TransactionErrorString(const TransactionError err)
std::string InvalidEstimateModeErrorMessage()
std::string StringForFeeReason(FeeReason reason)
bilingual_str ErrorString(const Result< T > &result)
Result CreateRateBumpTransaction(CWallet &wallet, const Txid &txid, const CCoinControl &coin_control, std::vector< bilingual_str > &errors, CAmount &old_fee, CAmount &new_fee, CMutableTransaction &mtx, bool require_mine, const std::vector< CTxOut > &outputs, std::optional< uint32_t > original_change_index)
Create bumpfee transaction based on feerate estimates.
bool SignTransaction(CWallet &wallet, CMutableTransaction &mtx)
Sign the new transaction,.
Result CommitTransaction(CWallet &wallet, const Txid &txid, CMutableTransaction &&mtx, std::vector< bilingual_str > &errors, Txid &bumped_txid)
Commit the bumpfee transaction.
CreatedTransactionResult FundTransaction(CWallet &wallet, const CMutableTransaction &tx, const std::vector< CRecipient > &recipients, const UniValue &options, CCoinControl &coinControl, bool override_min_fee)
std::shared_ptr< CWallet > GetWalletForJSONRPCRequest(const JSONRPCRequest &request)
Figures out what wallet, if any, to use for a JSONRPCRequest.
util::Result< CreatedTransactionResult > CreateTransaction(CWallet &wallet, const std::vector< CRecipient > &vecSend, std::optional< unsigned int > change_pos, const CCoinControl &coin_control, bool sign)
Create a new transaction paying the recipients with a set of coins selected by SelectCoins(); Also cr...
std::map< std::string, std::string > mapValue_t
static RPCHelpMan bumpfee_helper(std::string method_name)
RPCHelpMan walletprocesspsbt()
void EnsureWalletIsUnlocked(const CWallet &wallet)
const std::string HELP_REQUIRING_PASSPHRASE
static void SetFeeEstimateMode(const CWallet &wallet, CCoinControl &cc, const UniValue &conf_target, const UniValue &estimate_mode, const UniValue &fee_rate, bool override_min_fee)
Update coin control with fee estimation based on the given parameters.
bool IsDust(const CRecipient &recipient, const CFeeRate &dustRelayFee)
RPCHelpMan walletcreatefundedpsbt()
static void InterpretFeeEstimationInstructions(const UniValue &conf_target, const UniValue &estimate_mode, const UniValue &fee_rate, UniValue &options)
static void SetOptionsInputWeights(const UniValue &inputs, UniValue &options)
RPCHelpMan signrawtransactionwithwallet()
CFeeRate GetMinimumFeeRate(const CWallet &wallet, const CCoinControl &coin_control, FeeCalculation *feeCalc)
Estimate the minimum fee rate considering user set parameters and the required fee.
UniValue SendMoney(CWallet &wallet, const CCoinControl &coin_control, std::vector< CRecipient > &recipients, mapValue_t map_value, bool verbose)
static void PreventOutdatedOptions(const UniValue &options)
std::vector< CRecipient > CreateRecipients(const std::vector< std::pair< CTxDestination, CAmount > > &outputs, const std::set< int > &subtract_fee_outputs)
static std::vector< RPCArg > FundTxDoc(bool solving_data=true)
void DiscourageFeeSniping(CMutableTransaction &tx, FastRandomContext &rng_fast, interfaces::Chain &chain, const uint256 &block_hash, int block_height)
Set a height-based locktime for new transactions (uses the height of the current chain tip unless we ...
static std::vector< RPCArg > OutputsDoc()
bool GetAvoidReuseFlag(const CWallet &wallet, const UniValue ¶m)
RPCHelpMan fundrawtransaction()
static UniValue FinishTransaction(const std::shared_ptr< CWallet > pwallet, const UniValue &options, CMutableTransaction &rawTx)
TxSize CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const std::vector< CTxOut > &txouts, const CCoinControl *coin_control)
Calculate the size of the transaction using CoinControl to determine whether to expect signature grin...
@ WALLET_FLAG_EXTERNAL_SIGNER
Indicates that the wallet needs an external signer.
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
std::set< int > InterpretSubtractFeeFromOutputInstructions(const UniValue &sffo_instructions, const std::vector< std::string > &destinations)
RPCHelpMan sendtoaddress()
CoinsResult AvailableCoins(const CWallet &wallet, const CCoinControl *coinControl, std::optional< CFeeRate > feerate, const CoinFilterParams ¶ms)
Populate the CoinsResult struct with vectors of available COutputs, organized by OutputType.
const int DEFAULT_WALLET_TX_VERSION
is a home for public enum and struct type definitions that are used internally by node code,...
std::string FormatAllOutputTypes()
std::optional< OutputType > ParseOutputType(const std::string &type)
static constexpr unsigned int DEFAULT_INCREMENTAL_RELAY_FEE
Default for -incrementalrelayfee, which sets the minimum feerate increase for mempool limiting or rep...
static constexpr int32_t MAX_STANDARD_TX_WEIGHT
The maximum weight for transactions we're willing to relay/mine.
static constexpr TransactionSerParams TX_WITH_WITNESS
static CTransactionRef MakeTransactionRef(Tx &&txIn)
std::shared_ptr< const CTransaction > CTransactionRef
bool DecodeBase64PSBT(PartiallySignedTransaction &psbt, const std::string &base64_tx, std::string &error)
Decode a base64ed PSBT into a PartiallySignedTransaction.
bool FinalizeAndExtractPSBT(PartiallySignedTransaction &psbtx, CMutableTransaction &result)
Finalizes a PSBT if possible, and extracts it to a CMutableTransaction if it could be finalized.
void SignTransactionResultToJSON(CMutableTransaction &mtx, bool complete, const std::map< COutPoint, Coin > &coins, const std::map< int, bilingual_str > &input_errors, UniValue &result)
void AddOutputs(CMutableTransaction &rawTx, const UniValue &outputs_in)
Normalize, parse, and add outputs to the transaction.
CMutableTransaction ConstructTransaction(const UniValue &inputs_in, const UniValue &outputs_in, const UniValue &locktime, std::optional< bool > rbf, const uint32_t version)
Create a transaction from univalue parameters.
std::vector< std::pair< CTxDestination, CAmount > > ParseOutputs(const UniValue &outputs)
Parse normalized outputs into destination, amount tuples.
UniValue NormalizeOutputs(const UniValue &outputs_in)
Normalize univalue-represented outputs.
void ParsePrevouts(const UniValue &prevTxsUnival, FlatSigningProvider *keystore, std::map< COutPoint, Coin > &coins)
Parse a prevtxs UniValue array and get the map of coins from it.
UniValue JSONRPCError(int code, const std::string &message)
@ RPC_MISC_ERROR
General application defined errors.
@ RPC_WALLET_INSUFFICIENT_FUNDS
Not enough funds in wallet or account.
@ RPC_METHOD_DEPRECATED
RPC method is deprecated.
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
@ RPC_WALLET_ERROR
Wallet errors.
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
@ RPC_INVALID_REQUEST
Standard JSON-RPC 2.0 errors.
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
UniValue JSONRPCPSBTError(PSBTError err)
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
CPubKey HexToPubKey(const std::string &hex_in)
std::optional< int > ParseSighashString(const UniValue &sighash)
Returns a sighash value corresponding to the passed in argument.
const std::string EXAMPLE_ADDRESS[2]
Example bech32 addresses for the RPCExamples help documentation.
uint256 ParseHashO(const UniValue &o, std::string_view strKey)
unsigned int ParseConfirmTarget(const UniValue &value, unsigned int max_target)
Parse a confirm target option and raise an RPC error if it is invalid.
void RPCTypeCheckObj(const UniValue &o, const std::map< std::string, UniValueType > &typesExpected, bool fAllowNull, bool fStrict)
uint256 ParseHashV(const UniValue &v, std::string_view name)
Utilities: convert hex-encoded Values (throws error if not hex).
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
A mutable version of CTransaction.
std::vector< CTxOut > vout
FlatSigningProvider & Merge(FlatSigningProvider &&b) LIFETIMEBOUND
std::map< CKeyID, CPubKey > pubkeys
std::map< CScriptID, CScript > scripts
A version of CTransaction with the PSBT format.
@ OBJ_USER_KEYS
Special type where the user must set the keys e.g. to define multiple addresses; as opposed to e....
@ STR_HEX
Special type that is a STR with only hex chars.
@ AMOUNT
Special type representing a floating point amount (can be either NUM or STR)
@ OBJ_NAMED_PARAMS
Special type that behaves almost exactly like OBJ, defining an options object with a list of pre-defi...
std::string DefaultHint
Hint for default value.
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
std::string oneline_description
Should be empty unless it is supposed to override the auto-generated summary line.
bool also_positional
If set allows a named-parameter field in an OBJ_NAMED_PARAM options object to have the same name as a...
@ STR_HEX
Special string with only hex chars.
@ STR_AMOUNT
Special string to represent a floating point amount.
Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type.
A UTXO under consideration for use in funding a new transaction.
static constexpr int64_t TRUC_MAX_WEIGHT
static constexpr decltype(CTransaction::version) TRUC_VERSION
static constexpr int64_t TRUC_CHILD_MAX_WEIGHT
const char * uvTypeName(UniValue::VType t)
static constexpr uint32_t MAX_BIP125_RBF_SEQUENCE
bool IsHex(std::string_view str)
std::string EncodeBase64(std::span< const unsigned char > input)
V Cat(V v1, V &&v2)
Concatenate two vectors, moving elements.