spend.h

Go to the documentation of this file.

// Copyright (c) 2021 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_WALLET_SPEND_H
#define BITCOIN_WALLET_SPEND_H
 
#include <util/result.h>
#include <wallet/coinselection.h>
#include <wallet/transaction.h>
#include <wallet/wallet.h>
 
#include <optional>
 
int GetTxSpendSize(const CWallet &wallet, const CWalletTx &wtx,
                   unsigned int out, bool use_max_sig = false);
 
class COutput {
public:
    const CWalletTx *tx;
    int i;
    int nDepth;
 
    int nInputBytes;
 
    bool fSpendable;
 
    bool fSolvable;
 
    bool use_max_sig;
 
    bool fSafe;
 
    COutput(const CWallet &wallet, const CWalletTx &wtx, int iIn, int nDepthIn,
            bool fSpendableIn, bool fSolvableIn, bool fSafeIn,
            bool use_max_sig_in = false) {
        tx = &wtx;
        i = iIn;
        nDepth = nDepthIn;
        fSpendable = fSpendableIn;
        fSolvable = fSolvableIn;
        fSafe = fSafeIn;
        nInputBytes = -1;
        use_max_sig = use_max_sig_in;
        // If known and signable by the given wallet, compute nInputBytes
        // Failure will keep this value -1
        if (fSpendable) {
            nInputBytes = GetTxSpendSize(wallet, wtx, i, use_max_sig);
        }
    }
 
    std::string ToString() const;
 
    inline CInputCoin GetInputCoin() const {
        return CInputCoin(tx->tx, i, nInputBytes);
    }
};
 
int CalculateMaximumSignedInputSize(const CTxOut &txout, const CWallet *pwallet,
                                    bool use_max_sig = false);
 
int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
                                     const CWallet *wallet,
                                     const std::vector<CTxOut> &txouts,
                                     bool use_max_sig = false);
int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
                                     const CWallet *wallet,
                                     bool use_max_sig = false)
    EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet);
 
void AvailableCoins(const CWallet &wallet, std::vector<COutput> &vCoins,
                    const CCoinControl *coinControl = nullptr,
                    const Amount nMinimumAmount = SATOSHI,
                    const Amount nMaximumAmount = MAX_MONEY,
                    const Amount nMinimumSumAmount = MAX_MONEY,
                    const uint64_t nMaximumCount = 0)
    EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
 
Amount GetAvailableBalance(const CWallet &wallet,
                           const CCoinControl *coinControl = nullptr);
 
const CTxOut &FindNonChangeParentOutput(const CWallet &wallet,
                                        const CTransaction &tx, int output)
    EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
 
std::map<CTxDestination, std::vector<COutput>> ListCoins(const CWallet &wallet)
    EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
 
std::vector<OutputGroup>
GroupOutputs(const CWallet &wallet, const std::vector<COutput> &outputs,
             bool separate_coins, const CFeeRate &effective_feerate,
             const CFeeRate &long_term_feerate,
             const CoinEligibilityFilter &filter, bool positive_only);
 
bool SelectCoinsMinConf(const CWallet &wallet, const Amount nTargetValue,
                        const CoinEligibilityFilter &eligibility_filter,
                        std::vector<COutput> coins,
                        std::set<CInputCoin> &setCoinsRet, Amount &nValueRet,
                        const CoinSelectionParams &coin_selection_params,
                        bool &bnb_used);
 
bool SelectCoins(const CWallet &wallet,
                 const std::vector<COutput> &vAvailableCoins,
                 const Amount nTargetValue, std::set<CInputCoin> &setCoinsRet,
                 Amount &nValueRet, const CCoinControl &coin_control,
                 CoinSelectionParams &coin_selection_params, bool &bnb_used)
    EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
 
struct CreatedTransactionResult {
    CTransactionRef tx;
    Amount fee;
    int change_pos;
 
    CreatedTransactionResult(CTransactionRef tx, Amount fee, int change_pos)
        : tx(tx), fee(fee), change_pos(change_pos) {}
};
 
util::Result<CreatedTransactionResult>
CreateTransaction(CWallet &wallet, const std::vector<CRecipient> &vecSend,
                  int change_pos, const CCoinControl &coin_control,
                  bool sign = true);
 
bool FundTransaction(CWallet &wallet, CMutableTransaction &tx, Amount &nFeeRet,
                     int &nChangePosInOut, bilingual_str &error,
                     bool lockUnspents,
                     const std::set<int> &setSubtractFeeFromOutputs,
                     CCoinControl coinControl);
 
#endif // BITCOIN_WALLET_SPEND_H