751    bool solved = SignStep(provider, creator, fromPubKey, result, whichType, SigVersion::BASE, sigdata);
752    bool P2SH = false;
753    CScript subscript;
754
755    if (solved && whichType == TxoutType::SCRIPTHASH)
756    {
757        // Solver returns the subscript that needs to be evaluated;
758        // the final scriptSig is the signatures from that
759        // and then the serialized subscript:
760        subscript = CScript(result[0].begin(), result[0].end());
761        sigdata.redeem_script = subscript;
762        solved = solved && SignStep(provider, creator, subscript, result, whichType, SigVersion::BASE, sigdata) && whichType != TxoutType::SCRIPTHASH;
763        P2SH = true;
764    }
765
766    if (solved && whichType == TxoutType::WITNESS_V0_KEYHASH)
767    {
768        CScript witnessscript;
769        witnessscript << OP_DUP << OP_HASH160 << ToByteVector(result[0]) << OP_EQUALVERIFY << OP_CHECKSIG;
770        TxoutType subType;
771        solved = solved && SignStep(provider, creator, witnessscript, result, subType, SigVersion::WITNESS_V0, sigdata);
772        sigdata.scriptWitness.stack = result;
773        sigdata.witness = true;
774        result.clear();
775    }
776    else if (solved && whichType == TxoutType::WITNESS_V0_SCRIPTHASH)
777    {
778        CScript witnessscript(result[0].begin(), result[0].end());
779        sigdata.witness_script = witnessscript;
780
781        TxoutType subType{TxoutType::NONSTANDARD};
782        solved = solved && SignStep(provider, creator, witnessscript, result, subType, SigVersion::WITNESS_V0, sigdata) && subType != TxoutType::SCRIPTHASH && subType != TxoutType::WITNESS_V0_SCRIPTHASH && subType != TxoutType::WITNESS_V0_KEYHASH;
783
784        // If we couldn't find a solution with the legacy satisfier, try satisfying the script using Miniscript.
785        // Note we need to check if the result stack is empty before, because it might be used even if the Script
786        // isn't fully solved. For instance the CHECKMULTISIG satisfaction in SignStep() pushes partial signatures
787        // and the extractor relies on this behaviour to combine witnesses.
788        if (!solved && result.empty()) {
789            WshSatisfier ms_satisfier{provider, sigdata, creator, witnessscript};
790            const auto ms = miniscript::FromScript(witnessscript, ms_satisfier);
791            solved = ms && ms->Satisfy(ms_satisfier, result) == miniscript::Availability::YES;
792        }
793        result.emplace_back(witnessscript.begin(), witnessscript.end());
794
795        sigdata.scriptWitness.stack = result;
796        sigdata.witness = true;
797        result.clear();
798    } else if (whichType == TxoutType::WITNESS_V1_TAPROOT && !P2SH) {
799        sigdata.witness = true;
800        if (solved) {
801            sigdata.scriptWitness.stack = std::move(result);
802        }
803        result.clear();
804    } else if (solved && whichType == TxoutType::WITNESS_UNKNOWN) {
805        sigdata.witness = true;
806    }
807
808    if (!sigdata.witness) sigdata.scriptWitness.stack.clear();
809    if (P2SH) {
810        result.emplace_back(subscript.begin(), subscript.end());
811    }
812    sigdata.scriptSig = PushAll(result);
813
814    // Test solution
815    sigdata.complete = solved && VerifyScript(sigdata.scriptSig, fromPubKey, &sigdata.scriptWitness, STANDARD_SCRIPT_VERIFY_FLAGS, creator.Checker());
816    return sigdata.complete;
817}
818
819namespace {
820class SignatureExtractorChecker final : public DeferringSignatureChecker
821{
822private:
823    SignatureData& sigdata;
824
825public:
826    SignatureExtractorChecker(SignatureData& sigdata, BaseSignatureChecker& checker) : DeferringSignatureChecker(checker), sigdata(sigdata) {}
827
828    bool CheckECDSASignature(const std::vector<unsigned char>& scriptSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const override
829    {
830        if (m_checker.CheckECDSASignature(scriptSig, vchPubKey, scriptCode, sigversion)) {
831            CPubKey pubkey(vchPubKey);
832            sigdata.signatures.emplace(pubkey.GetID(), SigPair(pubkey, scriptSig));
833            return true;
834        }
835        return false;
836    }
837};
838
839struct Stacks
840{
841    std::vector<valtype> script;
842    std::vector<valtype> witness;
843
844    Stacks() = delete;
845    Stacks(const Stacks&) = delete;
846    explicit Stacks(const SignatureData& data) : witness(data.scriptWitness.stack) {
847        EvalScript(script, data.scriptSig, SCRIPT_VERIFY_STRICTENC, BaseSignatureChecker(), SigVersion::BASE);
848    }
849};
850}
851
852// Extracts signatures and scripts from incomplete scriptSigs. Please do not extend this, use PSBT instead
853SignatureData DataFromTransaction(const CMutableTransaction& tx, unsigned int nIn, const CTxOut& txout)
854{
855    SignatureData data;
856    assert(tx.vin.size() > nIn);
857    data.scriptSig = tx.vin[nIn].scriptSig;
858    data.scriptWitness = tx.vin[nIn].scriptWitness;
859    Stacks stack(data);
860
861    // Get signatures
862    MutableTransactionSignatureChecker tx_checker(&tx, nIn, txout.nValue, MissingDataBehavior::FAIL);
863    SignatureExtractorChecker extractor_checker(data, tx_checker);
864    if (VerifyScript(data.scriptSig, txout.scriptPubKey, &data.scriptWitness, STANDARD_SCRIPT_VERIFY_FLAGS, extractor_checker)) {
865        data.complete = true;
866        return data;
867    }
868
869    // Get scripts
870    std::vector<std::vector<unsigned char>> solutions;
871    TxoutType script_type = Solver(txout.scriptPubKey, solutions);
872    SigVersion sigversion = SigVersion::BASE;
873    CScript next_script = txout.scriptPubKey;
874
875    if (script_type == TxoutType::SCRIPTHASH && !stack.script.empty() && !stack.script.back().empty()) {
876        // Get the redeemScript
877        CScript redeem_script(stack.script.back().begin(), stack.script.back().end());
878        data.redeem_script = redeem_script;
879        next_script = std::move(redeem_script);
880
881        // Get redeemScript type
882        script_type = Solver(next_script, solutions);
883        stack.script.pop_back();
884    }
885    if (script_type == TxoutType::WITNESS_V0_SCRIPTHASH && !stack.witness.empty() && !stack.witness.back().empty()) {
886        // Get the witnessScript
887        CScript witness_script(stack.witness.back().begin(), stack.witness.back().end());
888        data.witness_script = witness_script;
889        next_script = std::move(witness_script);
890
891        // Get witnessScript type
892        script_type = Solver(next_script, solutions);
893        stack.witness.pop_back();
894        stack.script = std::move(stack.witness);
895        stack.witness.clear();
896        sigversion = SigVersion::WITNESS_V0;
897    }
898    if (script_type == TxoutType::MULTISIG && !stack.script.empty()) {
899        // Build a map of pubkey -> signature by matching sigs to pubkeys:
900        assert(solutions.size() > 1);
901        unsigned int num_pubkeys = solutions.size()-2;
902        unsigned int last_success_key = 0;
903        for (const valtype& sig : stack.script) {
904            for (unsigned int i = last_success_key; i < num_pubkeys; ++i) {
905                const valtype& pubkey = solutions[i+1];
906                // We either have a signature for this pubkey, or we have found a signature and it is valid
907                if (data.signatures.contains(CPubKey(pubkey).GetID()) || extractor_checker.CheckECDSASignature(sig, pubkey, next_script, sigversion)) {
908                    last_success_key = i + 1;
909                    break;
910                }
911            }
912        }
913    }
914
915    return data;
916}
917
918void UpdateInput(CTxIn& input, const SignatureData& data)
919{
920    input.scriptSig = data.scriptSig;
921    input.scriptWitness = data.scriptWitness;
922}
923
924void SignatureData::MergeSignatureData(SignatureData sigdata)
925{
926    if (complete) return;
927    if (sigdata.complete) {
928        *this = std::move(sigdata);
929        return;
930    }
931    if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
932        redeem_script = sigdata.redeem_script;
933    }
934    if (witness_script.empty() && !sigdata.witness_script.empty()) {
935        witness_script = sigdata.witness_script;
936    }
937    signatures.insert(std::make_move_iterator(sigdata.signatures.begin()), std::make_move_iterator(sigdata.signatures.end()));
938}
939
940namespace {
941/** Dummy signature checker which accepts all signatures. */
942class DummySignatureChecker final : public BaseSignatureChecker
943{
944public:
945    DummySignatureChecker() = default;
946    bool CheckECDSASignature(const std::vector<unsigned char>& sig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const override { return sig.size() != 0; }
947    bool CheckSchnorrSignature(std::span<const unsigned char> sig, std::span<const unsigned char> pubkey, SigVersion sigversion, ScriptExecutionData& execdata, ScriptError* serror) const override { return sig.size() != 0; }
948    bool CheckLockTime(const CScriptNum& nLockTime) const override { return true; }
949    bool CheckSequence(const CScriptNum& nSequence) const override { return true; }
950};
951}
952
953const BaseSignatureChecker& DUMMY_CHECKER = DummySignatureChecker();
954
955namespace {
956class DummySignatureCreator final : public BaseSignatureCreator {
957private:
958    char m_r_len = 32;
959    char m_s_len = 32;
960public:
961    DummySignatureCreator(char r_len, char s_len) : m_r_len(r_len), m_s_len(s_len) {}
962    const BaseSignatureChecker& Checker() const override { return DUMMY_CHECKER; }
963    bool CreateSig(const SigningProvider& provider, std::vector<unsigned char>& vchSig, const CKeyID& keyid, const CScript& scriptCode, SigVersion sigversion) const override
964    {
965        // Create a dummy signature that is a valid DER-encoding
966        vchSig.assign(m_r_len + m_s_len + 7, '\000');
967        vchSig[0] = 0x30;
968        vchSig[1] = m_r_len + m_s_len + 4;
969        vchSig[2] = 0x02;
970        vchSig[3] = m_r_len;
971        vchSig[4] = 0x01;
972        vchSig[4 + m_r_len] = 0x02;
973        vchSig[5 + m_r_len] = m_s_len;
974        vchSig[6 + m_r_len] = 0x01;
975        vchSig[6 + m_r_len + m_s_len] = SIGHASH_ALL;
976        return true;
977    }
978    bool CreateSchnorrSig(const SigningProvider& provider, std::vector<unsigned char>& sig, const XOnlyPubKey& pubkey, const uint256* leaf_hash, const uint256* tweak, SigVersion sigversion) const override
979    {
980        sig.assign(64, '\000');
981        return true;
982    }
983    std::vector<uint8_t> CreateMuSig2Nonce(const SigningProvider& provider, const CPubKey& aggregate_pubkey, const CPubKey& script_pubkey, const CPubKey& part_pubkey, const uint256* leaf_hash, const uint256* merkle_root, SigVersion sigversion, const SignatureData& sigdata) const override
984    {
985        std::vector<uint8_t> out;
986        out.assign(MUSIG2_PUBNONCE_SIZE, '\000');
987        return out;
988    }
989    bool CreateMuSig2PartialSig(const SigningProvider& provider, uint256& partial_sig, const CPubKey& aggregate_pubkey, const CPubKey& script_pubkey, const CPubKey& part_pubkey, const uint256* leaf_hash, const std::vector<std::pair<uint256, bool>>& tweaks, SigVersion sigversion, const SignatureData& sigdata) const override
990    {
991        partial_sig = uint256::ONE;
992        return true;
993    }
994    bool CreateMuSig2AggregateSig(const std::vector<CPubKey>& participants, std::vector<uint8_t>& sig, const CPubKey& aggregate_pubkey, const CPubKey& script_pubkey, const uint256* leaf_hash, const std::vector<std::pair<uint256, bool>>& tweaks, SigVersion sigversion, const SignatureData& sigdata) const override
995    {
996        sig.assign(64, '\000');
997        return true;
998    }
999};
1000