25 if (
wallet.HasWalletSpend(wtx.tx)) {
26 errors.emplace_back(
Untranslated(
"Transaction has descendants in the wallet"));
31 if (
wallet.chain().hasDescendantsInMempool(wtx.GetHash())) {
32 errors.emplace_back(
Untranslated(
"Transaction has descendants in the mempool"));
37 if (
wallet.GetTxDepthInMainChain(wtx) != 0) {
38 errors.emplace_back(
Untranslated(
"Transaction has been mined, or is conflicted with a mined transaction"));
42 if (wtx.mapValue.count(
"replaced_by_txid")) {
43 errors.push_back(
Untranslated(
strprintf(
"Cannot bump transaction %s which was already bumped by transaction %s", wtx.GetHash().ToString(), wtx.mapValue.at(
"replaced_by_txid"))));
51 errors.emplace_back(
Untranslated(
"Transaction contains inputs that don't belong to this wallet"));
71 strprintf(
"New fee rate (%s) is lower than the minimum fee rate (%s) to get into the mempool -- ",
77 std::vector<COutPoint> reused_inputs;
78 reused_inputs.reserve(mtx.
vin.size());
80 reused_inputs.push_back(txin.
prevout);
83 std::optional<CAmount> combined_bump_fee =
wallet.chain().calculateCombinedBumpFee(reused_inputs, newFeerate);
84 if (!combined_bump_fee.has_value()) {
85 errors.push_back(
Untranslated(
strprintf(
"Failed to calculate bump fees, because unconfirmed UTXOs depend on an enormous cluster of unconfirmed transactions.")));
87 CAmount new_total_fee = newFeerate.
GetFee(maxTxSize) + combined_bump_fee.value();
89 CFeeRate incrementalRelayFee =
wallet.chain().relayIncrementalFee();
92 CAmount minTotalFee = old_fee + incrementalRelayFee.
GetFee(maxTxSize);
94 if (new_total_fee < minTotalFee) {
95 errors.push_back(
Untranslated(
strprintf(
"Insufficient total fee %s, must be at least %s (oldFee %s + incrementalFee %s)",
101 if (new_total_fee < requiredFee) {
102 errors.push_back(
Untranslated(
strprintf(
"Insufficient total fee (cannot be less than required fee %s)",
109 if (new_total_fee > max_tx_fee) {
110 errors.push_back(
Untranslated(
strprintf(
"Specified or calculated fee %s is too high (cannot be higher than -maxtxfee %s)",
134 CFeeRate node_incremental_relay_fee =
wallet.chain().relayIncrementalFee();
136 feerate += std::max(node_incremental_relay_fee, wallet_incremental_relay_fee);
142 return std::max(feerate, min_feerate);
151 if (wtx ==
nullptr)
return false;
153 std::vector<bilingual_str> errors_dummy;
159 CAmount& old_fee,
CAmount& new_fee,
CMutableTransaction& mtx,
bool require_mine,
const std::vector<CTxOut>& outputs, std::optional<uint32_t> original_change_index)
162 if (!outputs.empty() && original_change_index.has_value()) {
163 errors.emplace_back(
Untranslated(
"The options 'outputs' and 'original_change_index' are incompatible. You can only either specify a new set of outputs, or designate a change output to be recycled."));
172 auto it =
wallet.mapWallet.find(txid);
173 if (it ==
wallet.mapWallet.end()) {
174 errors.emplace_back(
Untranslated(
"Invalid or non-wallet transaction id"));
180 if (original_change_index.has_value() && original_change_index.value() >= wtx.
tx->vout.size()) {
181 errors.emplace_back(
Untranslated(
"Change position is out of range"));
187 std::map<COutPoint, Coin> coins;
189 std::vector<CTxOut> spent_outputs;
190 for (
const CTxIn& txin : wtx.
tx->vin) {
193 wallet.chain().findCoins(coins);
194 for (
const CTxIn& txin : wtx.
tx->vin) {
205 spent_outputs.push_back(coin.
out);
210 txdata.
Init(*wtx.
tx, std::move(spent_outputs),
true);
211 for (
unsigned int i = 0; i < wtx.
tx->vin.size(); ++i) {
212 const CTxIn& txin = wtx.
tx->vin.at(i);
239 for (
const auto& old_output : wtx.
tx->vout) {
240 output_value += old_output.nValue;
243 old_fee = input_value - output_value;
248 std::vector<CRecipient> recipients;
250 const auto& txouts = outputs.empty() ? wtx.
tx->vout : outputs;
251 for (
size_t i = 0; i < txouts.size(); ++i) {
252 const CTxOut& output = txouts.at(i);
255 if (original_change_index.has_value() ? original_change_index.value() == i :
OutputIsChange(
wallet, output)) {
259 recipients.push_back(recipient);
261 new_outputs_value += output.
nValue;
265 if (recipients.empty()) {
267 if (std::get_if<CNoDestination>(&new_coin_control.
destChange)) {
268 errors.emplace_back(
Untranslated(
"Unable to create transaction. Transaction must have at least one recipient"));
283 for (
auto& txin : temp_mtx.vin) {
287 temp_mtx.vout = txouts;
305 for (
const auto& inputs : wtx.
tx->vin) {
319 const auto& txr = *res;
339 wallet.FillPSBT(psbtx, complete, std::nullopt,
false,
true);
340 auto err{
wallet.FillPSBT(psbtx, complete, std::nullopt,
true,
false)};
341 if (err)
return false;
345 return wallet.SignTransaction(mtx);
352 if (!errors.empty()) {
356 if (it ==
wallet.mapWallet.end()) {
357 errors.emplace_back(
Untranslated(
"Invalid or non-wallet transaction id"));
376 bumped_txid = tx->GetHash();
378 errors.emplace_back(
Untranslated(
"Created new bumpfee transaction but could not mark the original transaction as replaced"));
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a scriptPubKey for the destination.
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)
Fee rate in satoshis per virtualbyte: CAmount / vB the feerate is represented internally as FeeFrac.
CAmount GetFeePerK() const
Return the fee in satoshis for a vsize of 1000 vbytes.
CAmount GetFee(int32_t virtual_bytes) const
Return the fee in satoshis for the given vsize in vbytes.
An outpoint - a combination of a transaction hash and an index n into its vout.
The basic transaction that is broadcasted on the network and contained in blocks.
An input of a transaction.
CScriptWitness scriptWitness
Only serialized through CTransaction.
An output of a transaction.
CTxOut out
unspent transaction output
std::string ToString() const
constexpr bool IsNull() const
Wrapped uint256 methods.
std::string GetHex() const
PreselectedInput & Select(const COutPoint &outpoint)
Lock-in the given output for spending.
bool IsExternalSelected(const COutPoint &outpoint) const
Returns true if the given output is selected as an external input.
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...
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.
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.
const Txid & GetHash() const LIFETIMEBOUND
std::vector< std::pair< std::string, std::string > > vOrderForm
mapValue_t mapValue
Key/value map with information about the transaction.
static int64_t GetTransactionInputWeight(const CTxIn &txin)
bool VerifyScript(const CScript &scriptSig, const CScript &scriptPubKey, const CScriptWitness *witness, unsigned int flags, const BaseSignatureChecker &checker, ScriptError *serror)
@ FAIL
Just act as if the signature was invalid.
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
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 TransactionCanBeBumped(const CWallet &wallet, const Txid &txid)
Return whether transaction can be bumped.
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.
bool OutputIsChange(const CWallet &wallet, const CTxOut &txout)
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...
bool AllInputsMine(const CWallet &wallet, const CTransaction &tx)
Returns whether all of the inputs belong to the wallet.
std::map< std::string, std::string > mapValue_t
static feebumper::Result PreconditionChecks(const CWallet &wallet, const CWalletTx &wtx, bool require_mine, std::vector< bilingual_str > &errors) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
Check whether transaction has descendant in wallet or mempool, or has been mined, or conflicts with a...
CFeeRate GetMinimumFeeRate(const CWallet &wallet, const CCoinControl &coin_control, FeeCalculation *feeCalc)
Estimate the minimum fee rate considering user set parameters and the required fee.
static CFeeRate EstimateFeeRate(const CWallet &wallet, const CWalletTx &wtx, const CAmount old_fee, const CCoinControl &coin_control)
static const CAmount WALLET_INCREMENTAL_RELAY_FEE
minimum recommended increment for replacement txs
static feebumper::Result CheckFeeRate(const CWallet &wallet, const CMutableTransaction &mtx, const CFeeRate &newFeerate, const int64_t maxTxSize, CAmount old_fee, std::vector< bilingual_str > &errors)
Check if the user provided a valid feeRate.
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.
CAmount GetRequiredFee(const CWallet &wallet, unsigned int nTxBytes)
Return the minimum required absolute fee for this size based on the required fee rate.
int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
Compute the virtual transaction size (weight reinterpreted as bytes).
static constexpr unsigned int STANDARD_SCRIPT_VERIFY_FLAGS
Standard script verification flags that standard transactions will comply with.
static CTransactionRef MakeTransactionRef(Tx &&txIn)
std::shared_ptr< const CTransaction > CTransactionRef
bool FinalizeAndExtractPSBT(PartiallySignedTransaction &psbtx, CMutableTransaction &result)
Finalizes a PSBT if possible, and extracts it to a CMutableTransaction if it could be finalized.
A mutable version of CTransaction.
A version of CTransaction with the PSBT format.
void Init(const T &tx, std::vector< CTxOut > &&spent_outputs, bool force=false)
Initialize this PrecomputedTransactionData with transaction data.
int64_t GetWeightDiffToMax() const
#define EXCLUSIVE_LOCKS_REQUIRED(...)
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.