Standardness, dust and policy virtual size

251                return state;
252            }
253            CScript subscript(stack.back().begin(), stack.back().end());
254            unsigned int sigop_count = subscript.GetSigOpCount(true);
255            if (sigop_count > MAX_P2SH_SIGOPS) {
256                state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs", strprintf("p2sh redeemscript sigops exceed limit (input %u: %u > %u)", i, sigop_count, MAX_P2SH_SIGOPS));
257                return state;
258            }
259        }
260    }
261
262    return state;
263}
264
265bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
266{
267    if (tx.IsCoinBase())
268        return true; // Coinbases are skipped
269
270    for (unsigned int i = 0; i < tx.vin.size(); i++)
271    {
272        // We don't care if witness for this input is empty, since it must not be bloated.
273        // If the script is invalid without witness, it would be caught sooner or later during validation.
274        if (tx.vin[i].scriptWitness.IsNull())
275            continue;
276
277        const CTxOut &prev = mapInputs.AccessCoin(tx.vin[i].prevout).out;
278
279        // get the scriptPubKey corresponding to this input:
280        CScript prevScript = prev.scriptPubKey;
281
282        // witness stuffing detected
283        if (prevScript.IsPayToAnchor()) {
284            return false;
285        }
286
287        bool p2sh = false;
288        if (prevScript.IsPayToScriptHash()) {
289            std::vector <std::vector<unsigned char> > stack;
290            // If the scriptPubKey is P2SH, we try to extract the redeemScript casually by converting the scriptSig
291            // into a stack. We do not check IsPushOnly nor compare the hash as these will be done later anyway.
292            // If the check fails at this stage, we know that this txid must be a bad one.
293            if (!EvalScript(stack, tx.vin[i].scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker(), SigVersion::BASE))
294                return false;
295            if (stack.empty())
296                return false;
297            prevScript = CScript(stack.back().begin(), stack.back().end());
298            p2sh = true;
299        }
300
301        int witnessversion = 0;
302        std::vector<unsigned char> witnessprogram;
303
304        // Non-witness program must not be associated with any witness
305        if (!prevScript.IsWitnessProgram(witnessversion, witnessprogram))
306            return false;
307
308        // Check P2WSH standard limits
309        if (witnessversion == 0 && witnessprogram.size() == WITNESS_V0_SCRIPTHASH_SIZE) {
310            if (tx.vin[i].scriptWitness.stack.back().size() > MAX_STANDARD_P2WSH_SCRIPT_SIZE)
311                return false;
312            size_t sizeWitnessStack = tx.vin[i].scriptWitness.stack.size() - 1;
313            if (sizeWitnessStack > MAX_STANDARD_P2WSH_STACK_ITEMS)
314                return false;
315            for (unsigned int j = 0; j < sizeWitnessStack; j++) {
316                if (tx.vin[i].scriptWitness.stack[j].size() > MAX_STANDARD_P2WSH_STACK_ITEM_SIZE)
317                    return false;
318            }
319        }
320
321        // Check policy limits for Taproot spends:
322        // - MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE limit for stack item size
323        // - No annexes
324        if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE && !p2sh) {
325            // Taproot spend (non-P2SH-wrapped, version 1, witness program size 32; see BIP 341)
326            std::span stack{tx.vin[i].scriptWitness.stack};
327            if (stack.size() >= 2 && !stack.back().empty() && stack.back()[0] == ANNEX_TAG) {
328                // Annexes are nonstandard as long as no semantics are defined for them.
329                return false;
330            }
331            if (stack.size() >= 2) {
332                // Script path spend (2 or more stack elements after removing optional annex)
333                const auto& control_block = SpanPopBack(stack);
334                SpanPopBack(stack); // Ignore script
335                if (control_block.empty()) return false; // Empty control block is invalid
336                if ((control_block[0] & TAPROOT_LEAF_MASK) == TAPROOT_LEAF_TAPSCRIPT) {
337                    // Leaf version 0xc0 (aka Tapscript, see BIP 342)
338                    for (const auto& item : stack) {
339                        if (item.size() > MAX_STANDARD_TAPSCRIPT_STACK_ITEM_SIZE) return false;
340                    }
341                }
342            } else if (stack.size() == 1) {
343                // Key path spend (1 stack element after removing optional annex)
344                // (no policy rules apply)
345            } else {
346                // 0 stack elements; this is already invalid by consensus rules
347                return false;
348            }
349        }
350    }
351    return true;
352}
353
354bool SpendsNonAnchorWitnessProg(const CTransaction& tx, const CCoinsViewCache& prevouts)
355{
356    if (tx.IsCoinBase()) {
357        return false;
358    }
359
360    int version;
361    std::vector<uint8_t> program;
362    for (const auto& txin: tx.vin) {
363        const auto& prev_spk{prevouts.AccessCoin(txin.prevout).out.scriptPubKey};
364
365        // Note this includes not-yet-defined witness programs.
366        if (prev_spk.IsWitnessProgram(version, program) && !prev_spk.IsPayToAnchor(version, program)) {
367            return true;
368        }
369
370        // For P2SH extract the redeem script and check if it spends a non-Taproot witness program. Note
371        // this is fine to call EvalScript (as done in ValidateInputsStandardness/IsWitnessStandard) because this
372        // function is only ever called after IsStandardTx, which checks the scriptsig is pushonly.
373        if (prev_spk.IsPayToScriptHash()) {
374            // If EvalScript fails or results in an empty stack, the transaction is invalid by consensus.
375            std::vector <std::vector<uint8_t>> stack;
376            if (!EvalScript(stack, txin.scriptSig, SCRIPT_VERIFY_NONE, BaseSignatureChecker{}, SigVersion::BASE)
377                || stack.empty()) {
378                continue;
379            }
380            const CScript redeem_script{stack.back().begin(), stack.back().end()};
381            if (redeem_script.IsWitnessProgram(version, program)) {
382                return true;
383            }
384        }
385    }
386
387    return false;
388}
389
390int64_t GetSigOpsAdjustedWeight(int64_t weight, int64_t sigop_cost, unsigned int bytes_per_sigop)
391{
392    return std::max(weight, sigop_cost * bytes_per_sigop);
393}
394
395int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
396{
397    return (GetSigOpsAdjustedWeight(nWeight, nSigOpCost, bytes_per_sigop) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR;
398}
399
400int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOpCost, unsigned int bytes_per_sigop)
401{
402    return GetVirtualTransactionSize(GetTransactionWeight(tx), nSigOpCost, bytes_per_sigop);
403}
404
405int64_t GetVirtualTransactionInputSize(const CTxIn& txin, int64_t nSigOpCost, unsigned int bytes_per_sigop)
406{
407    return GetVirtualTransactionSize(GetTransactionInputWeight(txin), nSigOpCost, bytes_per_sigop);
408}
409