Building a wallet payment

1251
1252    // vouts to the payees
1253    txNew.vout.reserve(vecSend.size() + 1); // + 1 because of possible later insert
1254    for (const auto& recipient : vecSend)
1255    {
1256        txNew.vout.emplace_back(recipient.nAmount, GetScriptForDestination(recipient.dest));
1257    }
1258    const CAmount change_amount = result.GetChange(coin_selection_params.min_viable_change, coin_selection_params.m_change_fee);
1259    if (change_amount > 0) {
1260        CTxOut newTxOut(change_amount, scriptChange);
1261        if (!change_pos) {
1262            // Insert change txn at random position:
1263            change_pos = rng_fast.randrange(txNew.vout.size() + 1);
1264        } else if ((unsigned int)*change_pos > txNew.vout.size()) {
1265            return util::Error{_("Transaction change output index out of range")};
1266        }
1267        txNew.vout.insert(txNew.vout.begin() + *change_pos, newTxOut);
1268    } else {
1269        change_pos = std::nullopt;
1270    }
1271
1272    // Shuffle selected coins and fill in final vin
1273    std::vector<std::shared_ptr<COutput>> selected_coins = result.GetShuffledInputVector();
1274
1275    if (coin_control.HasSelected() && coin_control.HasSelectedOrder()) {
1276        // When there are preselected inputs, we need to move them to be the first UTXOs
1277        // and have them be in the order selected. We can use stable_sort for this, where we
1278        // compare with the positions stored in coin_control. The COutputs that have positions
1279        // will be placed before those that don't, and those positions will be in order.
1280        std::stable_sort(selected_coins.begin(), selected_coins.end(),
1281            [&coin_control](const std::shared_ptr<COutput>& a, const std::shared_ptr<COutput>& b) {
1282                auto a_pos = coin_control.GetSelectionPos(a->outpoint);
1283                auto b_pos = coin_control.GetSelectionPos(b->outpoint);
1284                if (a_pos.has_value() && b_pos.has_value()) {
1285                    return a_pos.value() < b_pos.value();
1286                } else if (a_pos.has_value() && !b_pos.has_value()) {
1287                    return true;
1288                } else {
1289                    return false;
1290                }
1291            });
1292    }
1293
1294    // The sequence number is set to non-maxint so that DiscourageFeeSniping
1295    // works.
1296    //
1297    // BIP125 defines opt-in RBF as any nSequence < maxint-1, so
1298    // we use the highest possible value in that range (maxint-2)
1299    // to avoid conflicting with other possible uses of nSequence,
1300    // and in the spirit of "smallest possible change from prior
1301    // behavior."
1302    bool use_anti_fee_sniping = true;
1303    const uint32_t default_sequence{coin_control.m_signal_bip125_rbf.value_or(wallet.m_signal_rbf) ? MAX_BIP125_RBF_SEQUENCE : CTxIn::MAX_SEQUENCE_NONFINAL};
1304    txNew.vin.reserve(selected_coins.size());
1305    for (const auto& coin : selected_coins) {
1306        std::optional<uint32_t> sequence = coin_control.GetSequence(coin->outpoint);
1307        if (sequence) {
1308            // If an input has a preset sequence, we can't do anti-fee-sniping
1309            use_anti_fee_sniping = false;
1310        }
1311        txNew.vin.emplace_back(coin->outpoint, CScript{}, sequence.value_or(default_sequence));
1312
1313        auto scripts = coin_control.GetScripts(coin->outpoint);
1314        if (scripts.first) {
1315            txNew.vin.back().scriptSig = *scripts.first;
1316        }
1317        if (scripts.second) {
1318            txNew.vin.back().scriptWitness = *scripts.second;
1319        }
1320    }
1321    if (coin_control.m_locktime) {
1322        txNew.nLockTime = coin_control.m_locktime.value();
1323        // If we have a locktime set, we can't use anti-fee-sniping
1324        use_anti_fee_sniping = false;
1325    }
1326    if (use_anti_fee_sniping) {
1327        DiscourageFeeSniping(txNew, rng_fast, wallet.chain(), wallet.GetLastBlockHash(), wallet.GetLastBlockHeight());
1328    }
1329
1330    // Calculate the transaction fee
1331    TxSize tx_sizes = CalculateMaximumSignedTxSize(CTransaction(txNew), &wallet, &coin_control);
1332    int nBytes = tx_sizes.vsize;
1333    if (nBytes == -1) {
1334        return util::Error{_("Missing solving data for estimating transaction size")};
1335    }
1336    CAmount fee_needed = coin_selection_params.m_effective_feerate.GetFee(nBytes) + result.GetTotalBumpFees();
1337    const CAmount output_value = CalculateOutputValue(txNew);
1338    Assume(recipients_sum + change_amount == output_value);
1339    CAmount current_fee = result.GetSelectedValue() - output_value;
1340
1341    // Sanity check that the fee cannot be negative as that means we have more output value than input value
1342    if (current_fee < 0) {
1343        return util::Error{Untranslated(STR_INTERNAL_BUG("Fee paid < 0"))};
1344    }
1345
1346    // If there is a change output and we overpay the fees then increase the change to match the fee needed
1347    if (change_pos && fee_needed < current_fee) {
1348        auto& change = txNew.vout.at(*change_pos);
1349        change.nValue += current_fee - fee_needed;
1350        current_fee = result.GetSelectedValue() - CalculateOutputValue(txNew);
1351        if (fee_needed != current_fee) {
1352            return util::Error{Untranslated(STR_INTERNAL_BUG("Change adjustment: Fee needed != fee paid"))};
1353        }
1354    }
1355
1356    // Reduce output values for subtractFeeFromAmount
1357    if (coin_selection_params.m_subtract_fee_outputs) {
1358        CAmount to_reduce = fee_needed - current_fee;
1359        unsigned int i = 0;
1360        bool fFirst = true;
1361        for (const auto& recipient : vecSend)
1362        {
1363            if (change_pos && i == *change_pos) {
1364                ++i;
1365            }
1366            CTxOut& txout = txNew.vout[i];
1367
1368            if (recipient.fSubtractFeeFromAmount)
1369            {
1370                txout.nValue -= to_reduce / outputs_to_subtract_fee_from; // Subtract fee equally from each selected recipient
1371
1372                if (fFirst) // first receiver pays the remainder not divisible by output count
1373                {
1374                    fFirst = false;
1375                    txout.nValue -= to_reduce % outputs_to_subtract_fee_from;
1376                }
1377
1378                // Error if this output is reduced to be below dust
1379                if (IsDust(txout, wallet.chain().relayDustFee())) {
1380                    if (txout.nValue < 0) {
1381                        return util::Error{_("The transaction amount is too small to pay the fee")};
1382                    } else {
1383                        return util::Error{_("The transaction amount is too small to send after the fee has been deducted")};
1384                    }
1385                }
1386            }
1387            ++i;
1388        }
1389        current_fee = result.GetSelectedValue() - CalculateOutputValue(txNew);
1390        if (fee_needed != current_fee) {
1391            return util::Error{Untranslated(STR_INTERNAL_BUG("SFFO: Fee needed != fee paid"))};
1392        }
1393    }
1394
1395    // fee_needed should now always be less than or equal to the current fees that we pay.
1396    // If it is not, it is a bug.
1397    if (fee_needed > current_fee) {
1398        return util::Error{Untranslated(STR_INTERNAL_BUG("Fee needed > fee paid"))};
1399    }
1400
1401    // Give up if change keypool ran out and change is required
1402    if (scriptChange.empty() && change_pos) {
1403        return util::Error{error};
1404    }
1405
1406    if (sign && !wallet.SignTransaction(txNew)) {
1407        return util::Error{_("Signing transaction failed")};
1408    }
1409
1410    // Return the constructed transaction data.
1411    CTransactionRef tx = MakeTransactionRef(std::move(txNew));
1412
1413    // Limit size
1414    if ((sign && GetTransactionWeight(*tx) > MAX_STANDARD_TX_WEIGHT) ||
1415        (!sign && tx_sizes.weight > MAX_STANDARD_TX_WEIGHT))
1416    {
1417        return util::Error{_("Transaction too large")};
1418    }
1419
1420    if (current_fee > wallet.m_default_max_tx_fee) {
1421        return util::Error{TransactionErrorString(TransactionError::MAX_FEE_EXCEEDED)};
1422    }
1423
1424    if (gArgs.GetBoolArg("-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS)) {
1425        // Lastly, ensure this tx will pass the mempool's chain limits
1426        auto result = wallet.chain().checkChainLimits(tx);
1427        if (!result) {
1428            return util::Error{util::ErrorString(result)};
1429        }
1430    }
1431
1432    // Before we return success, we assume any change key will be used to prevent
1433    // accidental reuse.
1434    reservedest.KeepDestination();
1435
1436    wallet.WalletLogPrintf("Coin Selection: Algorithm:%s, Waste Metric Score:%d\n", GetAlgorithmName(result.GetAlgo()), result.GetWaste());
1437    wallet.WalletLogPrintf("Fee Calculation: Fee:%d Bytes:%u, Source: %s\n",
1438                           current_fee, nBytes, StringForFeeReason(min_fee_rate.fee_reason));
1439    return CreatedTransactionResult(tx, current_fee, change_pos, min_fee_rate.fee_reason);
1440}
1441
1442util::Result<CreatedTransactionResult> CreateTransaction(
1443        CWallet& wallet,
1444        const std::vector<CRecipient>& vecSend,
1445        std::optional<unsigned int> change_pos,
1446        const CCoinControl& coin_control,
1447        bool sign)
1448{
1449    if (vecSend.empty()) {
1450        return util::Error{_("Transaction must have at least one recipient")};
1451    }
1452
1453    if (std::any_of(vecSend.cbegin(), vecSend.cend(), [](const auto& recipient){ return recipient.nAmount < 0; })) {
1454        return util::Error{_("Transaction amounts must not be negative")};
1455    }
1456
1457    LOCK(wallet.cs_wallet);
1458
1459    auto res = CreateTransactionInternal(wallet, vecSend, change_pos, coin_control, sign);
1460    TRACEPOINT(coin_selection, normal_create_tx_internal,
1461           wallet.GetName().c_str(),
1462           bool(res),
1463           res ? res->fee : 0,
1464           res && res->change_pos.has_value() ? int32_t(*res->change_pos) : -1);
1465    if (!res) return res;
1466    const auto& txr_ungrouped = *res;
1467    // try with avoidpartialspends unless it's enabled already
1468    if (txr_ungrouped.fee > 0 /* 0 means non-functional fee rate estimation */ && wallet.m_max_aps_fee > -1 && !coin_control.m_avoid_partial_spends) {
1469        TRACEPOINT(coin_selection, attempting_aps_create_tx, wallet.GetName().c_str());
1470        CCoinControl tmp_cc = coin_control;
1471        tmp_cc.m_avoid_partial_spends = true;
1472
1473        // Reuse the change destination from the first creation attempt to avoid skipping BIP44 indexes
1474        if (txr_ungrouped.change_pos) {
1475            ExtractDestination(txr_ungrouped.tx->vout[*txr_ungrouped.change_pos].scriptPubKey, tmp_cc.destChange);
1476        }
1477
1478        auto txr_grouped = CreateTransactionInternal(wallet, vecSend, change_pos, tmp_cc, sign);
1479        // if fee of this alternative one is within the range of the max fee, we use this one
1480        const bool use_aps{txr_grouped.has_value() ? (txr_grouped->fee <= txr_ungrouped.fee + wallet.m_max_aps_fee) : false};
1481        TRACEPOINT(coin_selection, aps_create_tx_internal,
1482               wallet.GetName().c_str(),
1483               use_aps,
1484               txr_grouped.has_value(),
1485               txr_grouped.has_value() ? txr_grouped->fee : 0,
1486               txr_grouped.has_value() && txr_grouped->change_pos.has_value() ? int32_t(*txr_grouped->change_pos) : -1);
1487        if (txr_grouped) {
1488            wallet.WalletLogPrintf("Fee non-grouped = %lld, grouped = %lld, using %s\n",
1489                txr_ungrouped.fee, txr_grouped->fee, use_aps ? "grouped" : "non-grouped");
1490            if (use_aps) return txr_grouped;
1491        }
1492    }
1493    return res;
1494}
1495
1496util::Result<CreatedTransactionResult> FundTransaction(CWallet& wallet, const CMutableTransaction& tx, const std::vector<CRecipient>& vecSend, std::optional<unsigned int> change_pos, bool lockUnspents, CCoinControl coinControl)
1497{
1498    // We want to make sure tx.vout is not used now that we are passing outputs as a vector of recipients.
1499    // This sets us up to remove tx completely in a future PR in favor of passing the inputs directly.
1500    assert(tx.vout.empty());