Method TestSatisfy

src/test/miniscript_tests.cpp:347–433

Run random satisfaction tests. */

struct MiniScriptTest : BasicTestingSetup {
/** Run random satisfaction tests. */
void TestSatisfy(const KeyConverter& converter, const Node& node)
{
    auto script = node.ToScript(converter);
    const auto challenges{FindChallenges(node)}; // Find all challenges in the generated miniscript.
    std::vector<Challenge> challist(challenges.begin(), challenges.end());
    for (int iter = 0; iter < 3; ++iter) {
        std::shuffle(challist.begin(), challist.end(), m_rng);
        Satisfier satisfier(converter.MsContext());
        TestSignatureChecker checker(satisfier);
        bool prev_mal_success = false, prev_nonmal_success = false;
        // Go over all challenges involved in this miniscript in random order.
        for (int add = -1; add < (int)challist.size(); ++add) {
            if (add >= 0) satisfier.supported.insert(challist[add]); // The first iteration does not add anything

            // Get the ScriptPubKey for this script, filling spend data if it's Taproot.
            TaprootBuilder builder;
            const CScript script_pubkey{ScriptPubKey(converter.MsContext(), script, builder)};

            // Run malleable satisfaction algorithm.
            CScriptWitness witness_mal;
            const bool mal_success = node.Satisfy(satisfier, witness_mal.stack, false) == miniscript::Availability::YES;
            SatisfactionToWitness(converter.MsContext(), witness_mal, script, builder);

            // Run non-malleable satisfaction algorithm.
            CScriptWitness witness_nonmal;
            const bool nonmal_success = node.Satisfy(satisfier, witness_nonmal.stack, true) == miniscript::Availability::YES;
            // Compute witness size (excluding script push, control block, and witness count encoding).
            const uint64_t wit_size{GetSerializeSize(witness_nonmal.stack) - GetSizeOfCompactSize(witness_nonmal.stack.size())};
            SatisfactionToWitness(converter.MsContext(), witness_nonmal, script, builder);

            if (nonmal_success) {
                // Non-malleable satisfactions are bounded by the satisfaction size plus:
                // - For P2WSH spends, the witness script
                // - For Tapscript spends, both the witness script and the control block
                const size_t max_stack_size{*node.GetStackSize() + 1 + miniscript::IsTapscript(converter.MsContext())};
                BOOST_CHECK(witness_nonmal.stack.size() <= max_stack_size);
                // If a non-malleable satisfaction exists, the malleable one must also exist, and be identical to it.
                BOOST_CHECK(mal_success);
                BOOST_CHECK(witness_nonmal.stack == witness_mal.stack);
                assert(wit_size <= *node.GetWitnessSize());

                // Test non-malleable satisfaction.
                ScriptError serror;
                bool res = VerifyScript(CScript(), script_pubkey, &witness_nonmal, STANDARD_SCRIPT_VERIFY_FLAGS, checker, &serror);
                // Non-malleable satisfactions are guaranteed to be valid if ValidSatisfactions().
                if (node.ValidSatisfactions()) BOOST_CHECK(res);
                // More detailed: non-malleable satisfactions must be valid, or could fail with ops count error (if CheckOpsLimit failed),
                // or with a stack size error (if CheckStackSize check fails).
                BOOST_CHECK(res ||
                            (!node.CheckOpsLimit() && serror == ScriptError::SCRIPT_ERR_OP_COUNT) ||
                            (!node.CheckStackSize() && serror == ScriptError::SCRIPT_ERR_STACK_SIZE));
            }

            if (mal_success && (!nonmal_success || witness_mal.stack != witness_nonmal.stack)) {
                // Test malleable satisfaction only if it's different from the non-malleable one.
                ScriptError serror;
                bool res = VerifyScript(CScript(), script_pubkey, &witness_mal, STANDARD_SCRIPT_VERIFY_FLAGS, checker, &serror);
                // Malleable satisfactions are not guaranteed to be valid under any conditions, but they can only