diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index f70eae810..be0a75d8b 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -1,872 +1,892 @@
 // Copyright (c) 2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <script/descriptor.h>
 
 #include <chainparams.h> // For Params()
 #include <config.h>
 #include <key_io.h>
 #include <pubkey.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <span.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace {
 
 ////////////////////////////////////////////////////////////////////////////
 // Internal representation                                                //
 ////////////////////////////////////////////////////////////////////////////
 
 typedef std::vector<uint32_t> KeyPath;
 
 std::string FormatKeyPath(const KeyPath &path) {
     std::string ret;
     for (auto i : path) {
         ret += strprintf("/%i", (i << 1) >> 1);
         if (i >> 31) {
             ret += '\'';
         }
     }
     return ret;
 }
 
 /** Interface for public key objects in descriptors. */
 struct PubkeyProvider {
     virtual ~PubkeyProvider() = default;
 
     /** Derive a public key. */
     virtual bool GetPubKey(int pos, const SigningProvider &arg, CPubKey &key,
                            KeyOriginInfo &info) const = 0;
 
     /** Whether this represent multiple public keys at different positions. */
     virtual bool IsRange() const = 0;
 
     /** Get the size of the generated public key(s) in bytes (33 or 65). */
     virtual size_t GetSize() const = 0;
 
     /** Get the descriptor string form. */
     virtual std::string ToString() const = 0;
 
     /**
      * Get the descriptor string form including private data (if available in
      * arg).
      */
     virtual bool ToPrivateString(const SigningProvider &arg,
                                  std::string &out) const = 0;
 };
 
 class OriginPubkeyProvider final : public PubkeyProvider {
     KeyOriginInfo m_origin;
     std::unique_ptr<PubkeyProvider> m_provider;
 
     std::string OriginString() const {
         return HexStr(std::begin(m_origin.fingerprint),
                       std::end(m_origin.fingerprint)) +
                FormatKeyPath(m_origin.path);
     }
 
 public:
     OriginPubkeyProvider(KeyOriginInfo info,
                          std::unique_ptr<PubkeyProvider> provider)
         : m_origin(std::move(info)), m_provider(std::move(provider)) {}
     bool GetPubKey(int pos, const SigningProvider &arg, CPubKey &key,
                    KeyOriginInfo &info) const override {
         if (!m_provider->GetPubKey(pos, arg, key, info)) {
             return false;
         }
         std::copy(std::begin(m_origin.fingerprint),
                   std::end(m_origin.fingerprint), info.fingerprint);
         info.path.insert(info.path.begin(), m_origin.path.begin(),
                          m_origin.path.end());
         return true;
     }
     bool IsRange() const override { return m_provider->IsRange(); }
     size_t GetSize() const override { return m_provider->GetSize(); }
     std::string ToString() const override {
         return "[" + OriginString() + "]" + m_provider->ToString();
     }
     bool ToPrivateString(const SigningProvider &arg,
                          std::string &ret) const override {
         std::string sub;
         if (!m_provider->ToPrivateString(arg, sub)) {
             return false;
         }
         ret = "[" + OriginString() + "]" + std::move(sub);
         return true;
     }
 };
 
 /** An object representing a parsed constant public key in a descriptor. */
 class ConstPubkeyProvider final : public PubkeyProvider {
     CPubKey m_pubkey;
 
 public:
     ConstPubkeyProvider(const CPubKey &pubkey) : m_pubkey(pubkey) {}
     bool GetPubKey(int pos, const SigningProvider &arg, CPubKey &key,
                    KeyOriginInfo &info) const override {
         key = m_pubkey;
         info.path.clear();
         CKeyID keyid = m_pubkey.GetID();
         std::copy(keyid.begin(), keyid.begin() + sizeof(info.fingerprint),
                   info.fingerprint);
         return true;
     }
     bool IsRange() const override { return false; }
     size_t GetSize() const override { return m_pubkey.size(); }
     std::string ToString() const override {
         return HexStr(m_pubkey.begin(), m_pubkey.end());
     }
     bool ToPrivateString(const SigningProvider &arg,
                          std::string &ret) const override {
         CKey key;
         if (!arg.GetKey(m_pubkey.GetID(), key)) {
             return false;
         }
         ret = EncodeSecret(key);
         return true;
     }
 };
 
 enum class DeriveType {
     NO,
     UNHARDENED,
     HARDENED,
 };
 
 /** An object representing a parsed extended public key in a descriptor. */
 class BIP32PubkeyProvider final : public PubkeyProvider {
     CExtPubKey m_extkey;
     KeyPath m_path;
     DeriveType m_derive;
 
     bool GetExtKey(const SigningProvider &arg, CExtKey &ret) const {
         CKey key;
         if (!arg.GetKey(m_extkey.pubkey.GetID(), key)) {
             return false;
         }
         ret.nDepth = m_extkey.nDepth;
         std::copy(m_extkey.vchFingerprint,
                   m_extkey.vchFingerprint + sizeof(ret.vchFingerprint),
                   ret.vchFingerprint);
         ret.nChild = m_extkey.nChild;
         ret.chaincode = m_extkey.chaincode;
         ret.key = key;
         return true;
     }
 
     bool IsHardened() const {
         if (m_derive == DeriveType::HARDENED) {
             return true;
         }
         for (auto entry : m_path) {
             if (entry >> 31) {
                 return true;
             }
         }
         return false;
     }
 
 public:
     BIP32PubkeyProvider(const CExtPubKey &extkey, KeyPath path,
                         DeriveType derive)
         : m_extkey(extkey), m_path(std::move(path)), m_derive(derive) {}
     bool IsRange() const override { return m_derive != DeriveType::NO; }
     size_t GetSize() const override { return 33; }
     bool GetPubKey(int pos, const SigningProvider &arg, CPubKey &key,
                    KeyOriginInfo &info) const override {
         if (IsHardened()) {
             CExtKey extkey;
             if (!GetExtKey(arg, extkey)) {
                 return false;
             }
             for (auto entry : m_path) {
                 extkey.Derive(extkey, entry);
             }
             if (m_derive == DeriveType::UNHARDENED) {
                 extkey.Derive(extkey, pos);
             }
             if (m_derive == DeriveType::HARDENED) {
                 extkey.Derive(extkey, pos | 0x80000000UL);
             }
             key = extkey.Neuter().pubkey;
         } else {
             // TODO: optimize by caching
             CExtPubKey extkey = m_extkey;
             for (auto entry : m_path) {
                 extkey.Derive(extkey, entry);
             }
             if (m_derive == DeriveType::UNHARDENED) {
                 extkey.Derive(extkey, pos);
             }
             assert(m_derive != DeriveType::HARDENED);
             key = extkey.pubkey;
         }
         CKeyID keyid = m_extkey.pubkey.GetID();
         std::copy(keyid.begin(), keyid.begin() + sizeof(info.fingerprint),
                   info.fingerprint);
         info.path = m_path;
         if (m_derive == DeriveType::UNHARDENED) {
             info.path.push_back(uint32_t(pos));
         }
         if (m_derive == DeriveType::HARDENED) {
             info.path.push_back(uint32_t(pos) | 0x80000000L);
         }
         return true;
     }
     std::string ToString() const override {
         std::string ret = EncodeExtPubKey(m_extkey) + FormatKeyPath(m_path);
         if (IsRange()) {
             ret += "/*";
             if (m_derive == DeriveType::HARDENED) {
                 ret += '\'';
             }
         }
         return ret;
     }
     bool ToPrivateString(const SigningProvider &arg,
                          std::string &out) const override {
         CExtKey key;
         if (!GetExtKey(arg, key)) {
             return false;
         }
         out = EncodeExtKey(key) + FormatKeyPath(m_path);
         if (IsRange()) {
             out += "/*";
             if (m_derive == DeriveType::HARDENED) {
                 out += '\'';
             }
         }
         return true;
     }
 };
 
-/** A parsed addr(A) descriptor. */
-class AddressDescriptor final : public Descriptor {
-    CTxDestination m_destination;
-
-public:
-    AddressDescriptor(CTxDestination destination)
-        : m_destination(std::move(destination)) {}
-
-    bool IsRange() const override { return false; }
-    bool IsSolvable() const override { return false; }
-    std::string ToString() const override {
-        return "addr(" + EncodeDestination(m_destination, GetConfig()) + ")";
-    }
-    bool ToPrivateString(const SigningProvider &arg,
-                         std::string &out) const override {
-        out = ToString();
-        return true;
-    }
-    bool Expand(int pos, const SigningProvider &arg,
-                std::vector<CScript> &output_scripts,
-                FlatSigningProvider &out) const override {
-        output_scripts =
-            std::vector<CScript>{GetScriptForDestination(m_destination)};
-        return true;
-    }
-};
-
-/** A parsed raw(H) descriptor. */
-class RawDescriptor final : public Descriptor {
-    CScript m_script;
-
-public:
-    RawDescriptor(CScript script) : m_script(std::move(script)) {}
-
-    bool IsRange() const override { return false; }
-    bool IsSolvable() const override { return false; }
-    std::string ToString() const override {
-        return "raw(" + HexStr(m_script.begin(), m_script.end()) + ")";
-    }
-    bool ToPrivateString(const SigningProvider &arg,
-                         std::string &out) const override {
-        out = ToString();
-        return true;
-    }
-    bool Expand(int pos, const SigningProvider &arg,
-                std::vector<CScript> &output_scripts,
-                FlatSigningProvider &out) const override {
-        output_scripts = std::vector<CScript>{m_script};
-        return true;
-    }
-};
+/** Base class for all Descriptor implementations. */
+class DescriptorImpl : public Descriptor {
+    //! Public key arguments for this descriptor (size 1 for PK, PKH; any size
+    //! of Multisig).
+    const std::vector<std::unique_ptr<PubkeyProvider>> m_pubkey_args;
+    //! The sub-descriptor argument (nullptr for everything but SH).
+    const std::unique_ptr<Descriptor> m_script_arg;
+    //! The string name of the descriptor function.
+    const std::string m_name;
+
+protected:
+    //! Return a serialization of anything except pubkey and script arguments,
+    //! to be prepended to those.
+    virtual std::string ToStringExtra() const { return ""; }
 
-/** A parsed pk(P), pkh(P) descriptor. */
-class SingleKeyDescriptor final : public Descriptor {
-    const std::function<CScript(const CPubKey &)> m_script_fn;
-    const std::string m_fn_name;
-    std::unique_ptr<PubkeyProvider> m_provider;
+    /**
+     * A helper function to construct the scripts for this descriptor.
+     *
+     *  This function is invoked once for every CScript produced by evaluating
+     *  m_script_arg, or just once in case m_script_arg is nullptr.
+
+     *  @param pubkeys The evaluations of the m_pubkey_args field.
+     *  @param script The evaluation of m_script_arg (or nullptr when
+     m_script_arg is nullptr).
+     *  @param out A FlatSigningProvider to put scripts or public keys in that
+     are necessary to the solver.
+     *             The script and pubkeys argument to this function are
+     automatically added.
+     *  @return A vector with scriptPubKeys for this descriptor.
+     */
+    virtual std::vector<CScript>
+    MakeScripts(const std::vector<CPubKey> &pubkeys, const CScript *script,
+                FlatSigningProvider &out) const = 0;
 
 public:
-    SingleKeyDescriptor(std::unique_ptr<PubkeyProvider> prov,
-                        const std::function<CScript(const CPubKey &)> &fn,
-                        const std::string &name)
-        : m_script_fn(fn), m_fn_name(name), m_provider(std::move(prov)) {}
-
-    bool IsRange() const override { return m_provider->IsRange(); }
-    bool IsSolvable() const override { return true; }
-    std::string ToString() const override {
-        return m_fn_name + "(" + m_provider->ToString() + ")";
-    }
-    bool ToPrivateString(const SigningProvider &arg,
-                         std::string &out) const override {
-        std::string ret;
-        if (!m_provider->ToPrivateString(arg, ret)) {
-            return false;
-        }
-        out = m_fn_name + "(" + std::move(ret) + ")";
-        return true;
-    }
-    bool Expand(int pos, const SigningProvider &arg,
-                std::vector<CScript> &output_scripts,
-                FlatSigningProvider &out) const override {
-        CPubKey key;
-        KeyOriginInfo info;
-        if (!m_provider->GetPubKey(pos, arg, key, info)) {
-            return false;
+    DescriptorImpl(std::vector<std::unique_ptr<PubkeyProvider>> pubkeys,
+                   std::unique_ptr<Descriptor> script, const std::string &name)
+        : m_pubkey_args(std::move(pubkeys)), m_script_arg(std::move(script)),
+          m_name(name) {}
+
+    bool IsSolvable() const override {
+        if (m_script_arg) {
+            if (!m_script_arg->IsSolvable()) {
+                return false;
+            }
         }
-        output_scripts = std::vector<CScript>{m_script_fn(key)};
-        out.origins.emplace(key.GetID(), std::move(info));
-        out.pubkeys.emplace(key.GetID(), key);
         return true;
     }
-};
-
-CScript P2PKHGetScript(const CPubKey &pubkey) {
-    return GetScriptForDestination(pubkey.GetID());
-}
-CScript P2PKGetScript(const CPubKey &pubkey) {
-    return GetScriptForRawPubKey(pubkey);
-}
-
-/** A parsed multi(...) descriptor. */
-class MultisigDescriptor : public Descriptor {
-    int m_threshold;
-    std::vector<std::unique_ptr<PubkeyProvider>> m_providers;
-
-public:
-    MultisigDescriptor(int threshold,
-                       std::vector<std::unique_ptr<PubkeyProvider>> providers)
-        : m_threshold(threshold), m_providers(std::move(providers)) {}
 
-    bool IsRange() const override {
-        for (const auto &p : m_providers) {
-            if (p->IsRange()) {
+    bool IsRange() const final {
+        for (const auto &pubkey : m_pubkey_args) {
+            if (pubkey->IsRange()) {
                 return true;
             }
         }
-        return false;
-    }
-
-    bool IsSolvable() const override { return true; }
-
-    std::string ToString() const override {
-        std::string ret = strprintf("multi(%i", m_threshold);
-        for (const auto &p : m_providers) {
-            ret += "," + p->ToString();
+        if (m_script_arg) {
+            if (m_script_arg->IsRange()) {
+                return true;
+            }
         }
-        return std::move(ret) + ")";
+        return false;
     }
 
     bool ToPrivateString(const SigningProvider &arg,
-                         std::string &out) const override {
-        std::string ret = strprintf("multi(%i", m_threshold);
-        for (const auto &p : m_providers) {
-            std::string sub;
-            if (!p->ToPrivateString(arg, sub)) {
+                         std::string &out) const final {
+        std::string extra = ToStringExtra();
+        size_t pos = extra.size() > 0 ? 1 : 0;
+        std::string ret = m_name + "(" + extra;
+        for (const auto &pubkey : m_pubkey_args) {
+            if (pos++) {
+                ret += ",";
+            }
+            std::string tmp;
+            if (!pubkey->ToPrivateString(arg, tmp)) {
+                return false;
+            }
+            ret += std::move(tmp);
+        }
+        if (m_script_arg) {
+            if (pos++) {
+                ret += ",";
+            }
+            std::string tmp;
+            if (!m_script_arg->ToPrivateString(arg, tmp)) {
                 return false;
             }
-            ret += "," + std::move(sub);
+            ret += std::move(tmp);
         }
         out = std::move(ret) + ")";
         return true;
     }
 
+    std::string ToString() const final {
+        std::string extra = ToStringExtra();
+        size_t pos = extra.size() > 0 ? 1 : 0;
+        std::string ret = m_name + "(" + extra;
+        for (const auto &pubkey : m_pubkey_args) {
+            if (pos++) {
+                ret += ",";
+            }
+            ret += pubkey->ToString();
+        }
+        if (m_script_arg) {
+            if (pos++) {
+                ret += ",";
+            }
+            ret += m_script_arg->ToString();
+        }
+        return std::move(ret) + ")";
+    }
+
     bool Expand(int pos, const SigningProvider &arg,
                 std::vector<CScript> &output_scripts,
-                FlatSigningProvider &out) const override {
+                FlatSigningProvider &out) const final {
         std::vector<std::pair<CPubKey, KeyOriginInfo>> entries;
-        entries.reserve(m_providers.size());
-        // Construct temporary data in `entries`, to avoid producing output in
-        // case of failure.
-        for (const auto &p : m_providers) {
+        entries.reserve(m_pubkey_args.size());
+
+        // Construct temporary data in `entries` and `subscripts`, to avoid
+        // producing output in case of failure.
+        for (const auto &p : m_pubkey_args) {
             entries.emplace_back();
             if (!p->GetPubKey(pos, arg, entries.back().first,
                               entries.back().second)) {
                 return false;
             }
         }
+        std::vector<CScript> subscripts;
+        if (m_script_arg) {
+            FlatSigningProvider subprovider;
+            if (!m_script_arg->Expand(pos, arg, subscripts, subprovider)) {
+                return false;
+            }
+            out = Merge(out, subprovider);
+        }
+
         std::vector<CPubKey> pubkeys;
         pubkeys.reserve(entries.size());
         for (auto &entry : entries) {
             pubkeys.push_back(entry.first);
             out.origins.emplace(entry.first.GetID(), std::move(entry.second));
             out.pubkeys.emplace(entry.first.GetID(), entry.first);
         }
-        output_scripts =
-            std::vector<CScript>{GetScriptForMultisig(m_threshold, pubkeys)};
+        if (m_script_arg) {
+            for (const auto &subscript : subscripts) {
+                out.scripts.emplace(CScriptID(subscript), subscript);
+                std::vector<CScript> addscripts =
+                    MakeScripts(pubkeys, &subscript, out);
+                for (auto &addscript : addscripts) {
+                    output_scripts.push_back(std::move(addscript));
+                }
+            }
+        } else {
+            output_scripts = MakeScripts(pubkeys, nullptr, out);
+        }
         return true;
     }
 };
 
-/** A parsed sh(S) descriptor. */
-class ConvertorDescriptor : public Descriptor {
-    const std::function<CScript(const CScript &)> m_convert_fn;
-    const std::string m_fn_name;
-    std::unique_ptr<Descriptor> m_descriptor;
+/** Construct a vector with one element, which is moved into it. */
+template <typename T> std::vector<T> Singleton(T elem) {
+    std::vector<T> ret;
+    ret.emplace_back(std::move(elem));
+    return ret;
+}
+
+/** A parsed addr(A) descriptor. */
+class AddressDescriptor final : public DescriptorImpl {
+    const CTxDestination m_destination;
+
+protected:
+    std::string ToStringExtra() const override {
+        return EncodeDestination(m_destination, GetConfig());
+    }
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
+                                     const CScript *,
+                                     FlatSigningProvider &) const override {
+        return Singleton(GetScriptForDestination(m_destination));
+    }
 
 public:
-    ConvertorDescriptor(std::unique_ptr<Descriptor> descriptor,
-                        const std::function<CScript(const CScript &)> &fn,
-                        const std::string &name)
-        : m_convert_fn(fn), m_fn_name(name),
-          m_descriptor(std::move(descriptor)) {}
-
-    bool IsRange() const override { return m_descriptor->IsRange(); }
-    bool IsSolvable() const override { return m_descriptor->IsSolvable(); }
-    std::string ToString() const override {
-        return m_fn_name + "(" + m_descriptor->ToString() + ")";
+    AddressDescriptor(CTxDestination destination)
+        : DescriptorImpl({}, {}, "addr"),
+          m_destination(std::move(destination)) {}
+    bool IsSolvable() const final { return false; }
+};
+
+/** A parsed raw(H) descriptor. */
+class RawDescriptor final : public DescriptorImpl {
+    const CScript m_script;
+
+protected:
+    std::string ToStringExtra() const override {
+        return HexStr(m_script.begin(), m_script.end());
     }
-    bool ToPrivateString(const SigningProvider &arg,
-                         std::string &out) const override {
-        std::string ret;
-        if (!m_descriptor->ToPrivateString(arg, ret)) {
-            return false;
-        }
-        out = m_fn_name + "(" + std::move(ret) + ")";
-        return true;
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
+                                     const CScript *,
+                                     FlatSigningProvider &) const override {
+        return Singleton(m_script);
     }
-    bool Expand(int pos, const SigningProvider &arg,
-                std::vector<CScript> &output_scripts,
-                FlatSigningProvider &out) const override {
-        std::vector<CScript> sub;
-        if (!m_descriptor->Expand(pos, arg, sub, out)) {
-            return false;
-        }
-        output_scripts.clear();
-        for (const auto &script : sub) {
-            CScriptID id(script);
-            out.scripts.emplace(CScriptID(script), script);
-            output_scripts.push_back(m_convert_fn(script));
-        }
-        return true;
+
+public:
+    RawDescriptor(CScript script)
+        : DescriptorImpl({}, {}, "raw"), m_script(std::move(script)) {}
+    bool IsSolvable() const final { return false; }
+};
+
+/** A parsed pk(P) descriptor. */
+class PKDescriptor final : public DescriptorImpl {
+protected:
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
+                                     const CScript *,
+                                     FlatSigningProvider &) const override {
+        return Singleton(GetScriptForRawPubKey(keys[0]));
     }
+
+public:
+    PKDescriptor(std::unique_ptr<PubkeyProvider> prov)
+        : DescriptorImpl(Singleton(std::move(prov)), {}, "pk") {}
 };
 
-CScript ConvertP2SH(const CScript &script) {
-    return GetScriptForDestination(CScriptID(script));
-}
+/** A parsed pkh(P) descriptor. */
+class PKHDescriptor final : public DescriptorImpl {
+protected:
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
+                                     const CScript *,
+                                     FlatSigningProvider &) const override {
+        return Singleton(GetScriptForDestination(keys[0].GetID()));
+    }
+
+public:
+    PKHDescriptor(std::unique_ptr<PubkeyProvider> prov)
+        : DescriptorImpl(Singleton(std::move(prov)), {}, "pkh") {}
+};
 
 /** A parsed combo(P) descriptor. */
-class ComboDescriptor final : public Descriptor {
-    std::unique_ptr<PubkeyProvider> m_provider;
+class ComboDescriptor final : public DescriptorImpl {
+protected:
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
+                                     const CScript *,
+                                     FlatSigningProvider &out) const override {
+        std::vector<CScript> ret;
+        CKeyID id = keys[0].GetID();
+        // P2PK
+        ret.emplace_back(GetScriptForRawPubKey(keys[0]));
+        // P2PKH
+        ret.emplace_back(GetScriptForDestination(id));
+        return ret;
+    }
 
 public:
-    ComboDescriptor(std::unique_ptr<PubkeyProvider> provider)
-        : m_provider(std::move(provider)) {}
+    ComboDescriptor(std::unique_ptr<PubkeyProvider> prov)
+        : DescriptorImpl(Singleton(std::move(prov)), {}, "combo") {}
+};
 
-    bool IsRange() const override { return m_provider->IsRange(); }
-    bool IsSolvable() const override { return true; }
-    std::string ToString() const override {
-        return "combo(" + m_provider->ToString() + ")";
+/** A parsed multi(...) descriptor. */
+class MultisigDescriptor final : public DescriptorImpl {
+    const int m_threshold;
+
+protected:
+    std::string ToStringExtra() const override {
+        return strprintf("%i", m_threshold);
     }
-    bool ToPrivateString(const SigningProvider &arg,
-                         std::string &out) const override {
-        std::string ret;
-        if (!m_provider->ToPrivateString(arg, ret)) {
-            return false;
-        }
-        out = "combo(" + std::move(ret) + ")";
-        return true;
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey> &keys,
+                                     const CScript *,
+                                     FlatSigningProvider &) const override {
+        return Singleton(GetScriptForMultisig(m_threshold, keys));
     }
-    bool Expand(int pos, const SigningProvider &arg,
-                std::vector<CScript> &output_scripts,
-                FlatSigningProvider &out) const override {
-        CPubKey key;
-        KeyOriginInfo info;
-        if (!m_provider->GetPubKey(pos, arg, key, info)) {
-            return false;
-        }
-        CKeyID keyid = key.GetID();
-        {
-            CScript p2pk = GetScriptForRawPubKey(key);
-            CScript p2pkh = GetScriptForDestination(keyid);
-            output_scripts =
-                std::vector<CScript>{std::move(p2pk), std::move(p2pkh)};
-            out.pubkeys.emplace(keyid, key);
-            out.origins.emplace(keyid, std::move(info));
-        }
-        return true;
+
+public:
+    MultisigDescriptor(int threshold,
+                       std::vector<std::unique_ptr<PubkeyProvider>> providers)
+        : DescriptorImpl(std::move(providers), {}, "multi"),
+          m_threshold(threshold) {}
+};
+
+/** A parsed sh(...) descriptor. */
+class SHDescriptor final : public DescriptorImpl {
+protected:
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey> &,
+                                     const CScript *script,
+                                     FlatSigningProvider &) const override {
+        return Singleton(GetScriptForDestination(CScriptID(*script)));
     }
+
+public:
+    SHDescriptor(std::unique_ptr<Descriptor> desc)
+        : DescriptorImpl({}, std::move(desc), "sh") {}
 };
 
 ////////////////////////////////////////////////////////////////////////////
 // Parser                                                                 //
 ////////////////////////////////////////////////////////////////////////////
 
 enum class ParseScriptContext {
     TOP,
     P2SH,
 };
 
 /**
  * Parse a constant. If successful, sp is updated to skip the constant and
  * return true.
  */
 bool Const(const std::string &str, Span<const char> &sp) {
     if ((size_t)sp.size() >= str.size() &&
         std::equal(str.begin(), str.end(), sp.begin())) {
         sp = sp.subspan(str.size());
         return true;
     }
     return false;
 }
 
 /**
  * Parse a function call. If successful, sp is updated to be the function's
  * argument(s).
  */
 bool Func(const std::string &str, Span<const char> &sp) {
     if ((size_t)sp.size() >= str.size() + 2 && sp[str.size()] == '(' &&
         sp[sp.size() - 1] == ')' &&
         std::equal(str.begin(), str.end(), sp.begin())) {
         sp = sp.subspan(str.size() + 1, sp.size() - str.size() - 2);
         return true;
     }
     return false;
 }
 
 /** Return the expression that sp begins with, and update sp to skip it. */
 Span<const char> Expr(Span<const char> &sp) {
     int level = 0;
     auto it = sp.begin();
     while (it != sp.end()) {
         if (*it == '(') {
             ++level;
         } else if (level && *it == ')') {
             --level;
         } else if (level == 0 && (*it == ')' || *it == ',')) {
             break;
         }
         ++it;
     }
     Span<const char> ret = sp.first(it - sp.begin());
     sp = sp.subspan(it - sp.begin());
     return ret;
 }
 
 /** Split a string on every instance of sep, returning a vector. */
 std::vector<Span<const char>> Split(const Span<const char> &sp, char sep) {
     std::vector<Span<const char>> ret;
     auto it = sp.begin();
     auto start = it;
     while (it != sp.end()) {
         if (*it == sep) {
             ret.emplace_back(start, it);
             start = it + 1;
         }
         ++it;
     }
     ret.emplace_back(start, it);
     return ret;
 }
 
 /**
  * Parse a key path, being passed a split list of elements (the first element is
  * ignored).
  */
 NODISCARD bool ParseKeyPath(const std::vector<Span<const char>> &split,
                             KeyPath &out) {
     for (size_t i = 1; i < split.size(); ++i) {
         Span<const char> elem = split[i];
         bool hardened = false;
         if (elem.size() > 0 &&
             (elem[elem.size() - 1] == '\'' || elem[elem.size() - 1] == 'h')) {
             elem = elem.first(elem.size() - 1);
             hardened = true;
         }
         uint32_t p;
         if (!ParseUInt32(std::string(elem.begin(), elem.end()), &p) ||
             p > 0x7FFFFFFFUL) {
             return false;
         }
         out.push_back(p | (uint32_t(hardened) << 31));
     }
     return true;
 }
 
-/**
- * Parse a public key that excludes origin information.
- */
+/** Parse a public key that excludes origin information. */
 std::unique_ptr<PubkeyProvider> ParsePubkeyInner(const Span<const char> &sp,
                                                  FlatSigningProvider &out) {
     auto split = Split(sp, '/');
     std::string str(split[0].begin(), split[0].end());
     if (split.size() == 1) {
         if (IsHex(str)) {
             std::vector<uint8_t> data = ParseHex(str);
             CPubKey pubkey(data);
             if (pubkey.IsFullyValid()) {
                 return std::make_unique<ConstPubkeyProvider>(pubkey);
             }
         }
         CKey key = DecodeSecret(str);
         if (key.IsValid()) {
             CPubKey pubkey = key.GetPubKey();
             out.keys.emplace(pubkey.GetID(), key);
             return std::make_unique<ConstPubkeyProvider>(pubkey);
         }
     }
     CExtKey extkey = DecodeExtKey(str);
     CExtPubKey extpubkey = DecodeExtPubKey(str);
     if (!extkey.key.IsValid() && !extpubkey.pubkey.IsValid()) {
         return nullptr;
     }
     KeyPath path;
     DeriveType type = DeriveType::NO;
     if (split.back() == MakeSpan("*").first(1)) {
         split.pop_back();
         type = DeriveType::UNHARDENED;
     } else if (split.back() == MakeSpan("*'").first(2) ||
                split.back() == MakeSpan("*h").first(2)) {
         split.pop_back();
         type = DeriveType::HARDENED;
     }
     if (!ParseKeyPath(split, path)) {
         return nullptr;
     }
     if (extkey.key.IsValid()) {
         extpubkey = extkey.Neuter();
         out.keys.emplace(extpubkey.pubkey.GetID(), extkey.key);
     }
     return std::make_unique<BIP32PubkeyProvider>(extpubkey, std::move(path),
                                                  type);
 }
 
-/**
- * Parse a public key including origin information (if enabled).
- */
+/** Parse a public key including origin information (if enabled). */
 std::unique_ptr<PubkeyProvider> ParsePubkey(const Span<const char> &sp,
                                             FlatSigningProvider &out) {
     auto origin_split = Split(sp, ']');
     if (origin_split.size() > 2) {
         return nullptr;
     }
     if (origin_split.size() == 1) {
         return ParsePubkeyInner(origin_split[0], out);
     }
     if (origin_split[0].size() < 1 || origin_split[0][0] != '[') {
         return nullptr;
     }
     auto slash_split = Split(origin_split[0].subspan(1), '/');
     if (slash_split[0].size() != 8) {
         return nullptr;
     }
     std::string fpr_hex =
         std::string(slash_split[0].begin(), slash_split[0].end());
     if (!IsHex(fpr_hex)) {
         return nullptr;
     }
     auto fpr_bytes = ParseHex(fpr_hex);
     KeyOriginInfo info;
     static_assert(sizeof(info.fingerprint) == 4, "Fingerprint must be 4 bytes");
     assert(fpr_bytes.size() == 4);
     std::copy(fpr_bytes.begin(), fpr_bytes.end(), info.fingerprint);
     if (!ParseKeyPath(slash_split, info.path)) {
         return nullptr;
     }
     auto provider = ParsePubkeyInner(origin_split[1], out);
     if (!provider) {
         return nullptr;
     }
     return std::make_unique<OriginPubkeyProvider>(std::move(info),
                                                   std::move(provider));
 }
 
 /** Parse a script in a particular context. */
 std::unique_ptr<Descriptor> ParseScript(Span<const char> &sp,
                                         ParseScriptContext ctx,
                                         FlatSigningProvider &out) {
     auto expr = Expr(sp);
     if (Func("pk", expr)) {
         auto pubkey = ParsePubkey(expr, out);
         if (!pubkey) {
             return nullptr;
         }
-        return std::make_unique<SingleKeyDescriptor>(std::move(pubkey),
-                                                     P2PKGetScript, "pk");
+        return std::make_unique<PKDescriptor>(std::move(pubkey));
     }
     if (Func("pkh", expr)) {
         auto pubkey = ParsePubkey(expr, out);
         if (!pubkey) {
             return nullptr;
         }
-        return std::make_unique<SingleKeyDescriptor>(std::move(pubkey),
-                                                     P2PKHGetScript, "pkh");
+        return std::make_unique<PKHDescriptor>(std::move(pubkey));
     }
     if (ctx == ParseScriptContext::TOP && Func("combo", expr)) {
         auto pubkey = ParsePubkey(expr, out);
         if (!pubkey) {
             return nullptr;
         }
         return std::make_unique<ComboDescriptor>(std::move(pubkey));
     }
     if (Func("multi", expr)) {
         auto threshold = Expr(expr);
         uint32_t thres;
         std::vector<std::unique_ptr<PubkeyProvider>> providers;
         if (!ParseUInt32(std::string(threshold.begin(), threshold.end()),
                          &thres)) {
             return nullptr;
         }
         size_t script_size = 0;
         while (expr.size()) {
             if (!Const(",", expr)) {
                 return nullptr;
             }
             auto arg = Expr(expr);
             auto pk = ParsePubkey(arg, out);
             if (!pk) {
                 return nullptr;
             }
             script_size += pk->GetSize() + 1;
             providers.emplace_back(std::move(pk));
         }
         if (providers.size() < 1 || providers.size() > 16 || thres < 1 ||
             thres > providers.size()) {
             return nullptr;
         }
         if (ctx == ParseScriptContext::TOP) {
             if (providers.size() > 3) {
                 // Not more than 3 pubkeys for raw multisig
                 return nullptr;
             }
         }
         if (ctx == ParseScriptContext::P2SH) {
             if (script_size + 3 > 520) {
                 // Enforce P2SH script size limit
                 return nullptr;
             }
         }
         return std::make_unique<MultisigDescriptor>(thres,
                                                     std::move(providers));
     }
     if (ctx == ParseScriptContext::TOP && Func("sh", expr)) {
         auto desc = ParseScript(expr, ParseScriptContext::P2SH, out);
         if (!desc || expr.size()) {
             return nullptr;
         }
-        return std::make_unique<ConvertorDescriptor>(std::move(desc),
-                                                     ConvertP2SH, "sh");
+        return std::make_unique<SHDescriptor>(std::move(desc));
     }
     if (ctx == ParseScriptContext::TOP && Func("addr", expr)) {
         CTxDestination dest =
             DecodeDestination(std::string(expr.begin(), expr.end()), Params());
         if (!IsValidDestination(dest)) {
             return nullptr;
         }
         return std::make_unique<AddressDescriptor>(std::move(dest));
     }
     if (ctx == ParseScriptContext::TOP && Func("raw", expr)) {
         std::string str(expr.begin(), expr.end());
         if (!IsHex(str)) {
             return nullptr;
         }
         auto bytes = ParseHex(str);
         return std::make_unique<RawDescriptor>(
             CScript(bytes.begin(), bytes.end()));
     }
     return nullptr;
 }
 
 static std::unique_ptr<PubkeyProvider>
 InferPubkey(const CPubKey &pubkey, ParseScriptContext,
             const SigningProvider &provider) {
     auto key_provider = std::make_unique<ConstPubkeyProvider>(pubkey);
     KeyOriginInfo info;
     if (provider.GetKeyOrigin(pubkey.GetID(), info)) {
         return std::make_unique<OriginPubkeyProvider>(std::move(info),
                                                       std::move(key_provider));
     }
     return key_provider;
 }
 
 std::unique_ptr<Descriptor> InferScript(const CScript &script,
                                         ParseScriptContext ctx,
                                         const SigningProvider &provider) {
     std::vector<std::vector<uint8_t>> data;
     txnouttype txntype = Solver(script, data);
 
     if (txntype == TX_PUBKEY) {
         CPubKey pubkey(data[0].begin(), data[0].end());
         if (pubkey.IsValid()) {
-            return std::make_unique<SingleKeyDescriptor>(
-                InferPubkey(pubkey, ctx, provider), P2PKGetScript, "pk");
+            return std::make_unique<PKDescriptor>(
+                InferPubkey(pubkey, ctx, provider));
         }
     }
     if (txntype == TX_PUBKEYHASH) {
         uint160 hash(data[0]);
         CKeyID keyid(hash);
         CPubKey pubkey;
         if (provider.GetPubKey(keyid, pubkey)) {
-            return std::make_unique<SingleKeyDescriptor>(
-                InferPubkey(pubkey, ctx, provider), P2PKHGetScript, "pkh");
+            return std::make_unique<PKHDescriptor>(
+                InferPubkey(pubkey, ctx, provider));
         }
     }
     if (txntype == TX_MULTISIG) {
         std::vector<std::unique_ptr<PubkeyProvider>> providers;
         for (size_t i = 1; i + 1 < data.size(); ++i) {
             CPubKey pubkey(data[i].begin(), data[i].end());
             providers.push_back(InferPubkey(pubkey, ctx, provider));
         }
         return std::make_unique<MultisigDescriptor>((int)data[0][0],
                                                     std::move(providers));
     }
     if (txntype == TX_SCRIPTHASH && ctx == ParseScriptContext::TOP) {
         uint160 hash(data[0]);
         CScriptID scriptid(hash);
         CScript subscript;
         if (provider.GetCScript(scriptid, subscript)) {
             auto sub =
                 InferScript(subscript, ParseScriptContext::P2SH, provider);
             if (sub) {
-                return std::make_unique<ConvertorDescriptor>(std::move(sub),
-                                                             ConvertP2SH, "sh");
+                return std::make_unique<SHDescriptor>(std::move(sub));
             }
         }
     }
 
     CTxDestination dest;
     if (ExtractDestination(script, dest)) {
         if (GetScriptForDestination(dest) == script) {
             return std::make_unique<AddressDescriptor>(std::move(dest));
         }
     }
 
     return std::make_unique<RawDescriptor>(script);
 }
 
 } // namespace
 
 std::unique_ptr<Descriptor> Parse(const std::string &descriptor,
                                   FlatSigningProvider &out) {
     Span<const char> sp(descriptor.data(), descriptor.size());
     auto ret = ParseScript(sp, ParseScriptContext::TOP, out);
     if (sp.size() == 0 && ret) {
         return ret;
     }
     return nullptr;
 }
 
 std::unique_ptr<Descriptor> InferDescriptor(const CScript &script,
                                             const SigningProvider &provider) {
     return InferScript(script, ParseScriptContext::TOP, provider);
 }
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index eac750246..6e968ae7e 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -1,506 +1,508 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <script/sign.h>
 
 #include <key.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/standard.h>
 #include <uint256.h>
 
 typedef std::vector<uint8_t> valtype;
 
 MutableTransactionSignatureCreator::MutableTransactionSignatureCreator(
     const CMutableTransaction *txToIn, unsigned int nInIn,
     const Amount &amountIn, SigHashType sigHashTypeIn)
     : txTo(txToIn), nIn(nInIn), amount(amountIn), sigHashType(sigHashTypeIn),
       checker(txTo, nIn, amountIn) {}
 
 bool MutableTransactionSignatureCreator::CreateSig(
     const SigningProvider &provider, std::vector<uint8_t> &vchSig,
     const CKeyID &address, const CScript &scriptCode) const {
     CKey key;
     if (!provider.GetKey(address, key)) {
         return false;
     }
 
     uint256 hash = SignatureHash(scriptCode, *txTo, nIn, sigHashType, amount);
     if (!key.SignECDSA(hash, vchSig)) {
         return false;
     }
 
     vchSig.push_back(uint8_t(sigHashType.getRawSigHashType()));
     return true;
 }
 
 static bool GetCScript(const SigningProvider &provider,
                        const SignatureData &sigdata, const CScriptID &scriptid,
                        CScript &script) {
     if (provider.GetCScript(scriptid, script)) {
         return true;
     }
     // Look for scripts in SignatureData
     if (CScriptID(sigdata.redeem_script) == scriptid) {
         script = sigdata.redeem_script;
         return true;
     }
     return false;
 }
 
 static bool GetPubKey(const SigningProvider &provider, SignatureData &sigdata,
                       const CKeyID &address, CPubKey &pubkey) {
     // Look for pubkey in all partial sigs
     const auto it = sigdata.signatures.find(address);
     if (it != sigdata.signatures.end()) {
         pubkey = it->second.first;
         return true;
     }
     // Look for pubkey in pubkey list
     const auto &pk_it = sigdata.misc_pubkeys.find(address);
     if (pk_it != sigdata.misc_pubkeys.end()) {
         pubkey = pk_it->second.first;
         return true;
     }
     // Query the underlying provider
     if (provider.GetPubKey(address, pubkey)) {
         KeyOriginInfo info;
         if (provider.GetKeyOrigin(address, info)) {
             sigdata.misc_pubkeys.emplace(
                 address, std::make_pair(pubkey, std::move(info)));
         }
         return true;
     }
     return false;
 }
 
 static bool CreateSig(const BaseSignatureCreator &creator,
                       SignatureData &sigdata, const SigningProvider &provider,
                       std::vector<uint8_t> &sig_out, const CPubKey &pubkey,
                       const CScript &scriptcode) {
     CKeyID keyid = pubkey.GetID();
     const auto it = sigdata.signatures.find(keyid);
     if (it != sigdata.signatures.end()) {
         sig_out = it->second.second;
         return true;
     }
     KeyOriginInfo info;
     if (provider.GetKeyOrigin(keyid, info)) {
         sigdata.misc_pubkeys.emplace(keyid,
                                      std::make_pair(pubkey, std::move(info)));
     }
     if (creator.CreateSig(provider, sig_out, keyid, scriptcode)) {
         auto i = sigdata.signatures.emplace(keyid, SigPair(pubkey, sig_out));
         assert(i.second);
         return true;
     }
     // Could not make signature or signature not found, add keyid to missing
     sigdata.missing_sigs.push_back(keyid);
     return false;
 }
 
 /**
  * Sign scriptPubKey using signature made with creator.
  * Signatures are returned in scriptSigRet (or returns false if scriptPubKey
  * can't be signed), unless whichTypeRet is TX_SCRIPTHASH, in which case
  * scriptSigRet is the redemption script.
  * Returns false if scriptPubKey could not be completely satisfied.
  */
 static bool SignStep(const SigningProvider &provider,
                      const BaseSignatureCreator &creator,
                      const CScript &scriptPubKey, std::vector<valtype> &ret,
                      txnouttype &whichTypeRet, SignatureData &sigdata) {
     CScript scriptRet;
     uint160 h160;
     ret.clear();
     std::vector<uint8_t> sig;
 
     std::vector<valtype> vSolutions;
     whichTypeRet = Solver(scriptPubKey, vSolutions);
 
     switch (whichTypeRet) {
         case TX_NONSTANDARD:
         case TX_NULL_DATA:
             return false;
         case TX_PUBKEY:
             if (!CreateSig(creator, sigdata, provider, sig,
                            CPubKey(vSolutions[0]), scriptPubKey)) {
                 return false;
             }
             ret.push_back(std::move(sig));
             return true;
         case TX_PUBKEYHASH: {
             CKeyID keyID = CKeyID(uint160(vSolutions[0]));
             CPubKey pubkey;
             if (!GetPubKey(provider, sigdata, keyID, pubkey)) {
                 // Pubkey could not be found, add to missing
                 sigdata.missing_pubkeys.push_back(keyID);
                 return false;
             }
             if (!CreateSig(creator, sigdata, provider, sig, pubkey,
                            scriptPubKey)) {
                 return false;
             }
             ret.push_back(std::move(sig));
             ret.push_back(ToByteVector(pubkey));
             return true;
         }
         case TX_SCRIPTHASH:
             h160 = uint160(vSolutions[0]);
             if (GetCScript(provider, sigdata, h160, scriptRet)) {
                 ret.push_back(
                     std::vector<uint8_t>(scriptRet.begin(), scriptRet.end()));
                 return true;
             }
             // Could not find redeemScript, add to missing
             sigdata.missing_redeem_script = h160;
             return false;
         case TX_MULTISIG: {
             size_t required = vSolutions.front()[0];
             // workaround CHECKMULTISIG bug
             ret.push_back(valtype());
             for (size_t i = 1; i < vSolutions.size() - 1; ++i) {
                 CPubKey pubkey = CPubKey(vSolutions[i]);
                 if (ret.size() < required + 1 &&
                     CreateSig(creator, sigdata, provider, sig, pubkey,
                               scriptPubKey)) {
                     ret.push_back(std::move(sig));
                 }
             }
             bool ok = ret.size() == required + 1;
             for (size_t i = 0; i + ret.size() < required + 1; ++i) {
                 ret.push_back(valtype());
             }
             return ok;
         }
         default:
             return false;
     }
 }
 
 static CScript PushAll(const std::vector<valtype> &values) {
     CScript result;
     for (const valtype &v : values) {
         if (v.size() == 0) {
             result << OP_0;
         } else if (v.size() == 1 && v[0] >= 1 && v[0] <= 16) {
             result << CScript::EncodeOP_N(v[0]);
         } else {
             result << v;
         }
     }
 
     return result;
 }
 
 bool ProduceSignature(const SigningProvider &provider,
                       const BaseSignatureCreator &creator,
                       const CScript &fromPubKey, SignatureData &sigdata) {
     if (sigdata.complete) {
         return true;
     }
 
     std::vector<valtype> result;
     txnouttype whichType;
     bool solved =
         SignStep(provider, creator, fromPubKey, result, whichType, sigdata);
     CScript subscript;
 
     if (solved && whichType == TX_SCRIPTHASH) {
         // Solver returns the subscript that needs to be evaluated; the final
         // scriptSig is the signatures from that and then the serialized
         // subscript:
         subscript = CScript(result[0].begin(), result[0].end());
         sigdata.redeem_script = subscript;
 
         solved = solved &&
                  SignStep(provider, creator, subscript, result, whichType,
                           sigdata) &&
                  whichType != TX_SCRIPTHASH;
         result.push_back(
             std::vector<uint8_t>(subscript.begin(), subscript.end()));
     }
 
     sigdata.scriptSig = PushAll(result);
 
     // Test solution
     sigdata.complete =
         solved && VerifyScript(sigdata.scriptSig, fromPubKey,
                                STANDARD_SCRIPT_VERIFY_FLAGS, creator.Checker());
     return sigdata.complete;
 }
 
 class SignatureExtractorChecker final : public BaseSignatureChecker {
 private:
     SignatureData &sigdata;
     BaseSignatureChecker &checker;
 
 public:
     SignatureExtractorChecker(SignatureData &sigdata_,
                               BaseSignatureChecker &checker_)
         : sigdata(sigdata_), checker(checker_) {}
     bool CheckSig(const std::vector<uint8_t> &scriptSig,
                   const std::vector<uint8_t> &vchPubKey,
                   const CScript &scriptCode, uint32_t flags) const override;
 };
 
 bool SignatureExtractorChecker::CheckSig(const std::vector<uint8_t> &scriptSig,
                                          const std::vector<uint8_t> &vchPubKey,
                                          const CScript &scriptCode,
                                          uint32_t flags) const {
     if (checker.CheckSig(scriptSig, vchPubKey, scriptCode, flags)) {
         CPubKey pubkey(vchPubKey);
         sigdata.signatures.emplace(pubkey.GetID(), SigPair(pubkey, scriptSig));
         return true;
     }
     return false;
 }
 
 namespace {
 struct Stacks {
     std::vector<valtype> script;
 
     Stacks() = delete;
     Stacks(const Stacks &) = delete;
     explicit Stacks(const SignatureData &data) {
         if (data.scriptSig.IsPushOnly()) {
             EvalScript(script, data.scriptSig, SCRIPT_VERIFY_NONE,
                        BaseSignatureChecker());
         }
     }
 };
 } // namespace
 
 // Extracts signatures and scripts from incomplete scriptSigs. Please do not
 // extend this, use PSBT instead
 SignatureData DataFromTransaction(const CMutableTransaction &tx,
                                   unsigned int nIn, const CTxOut &txout) {
     SignatureData data;
     assert(tx.vin.size() > nIn);
     data.scriptSig = tx.vin[nIn].scriptSig;
     Stacks stack(data);
 
     // Get signatures
     MutableTransactionSignatureChecker tx_checker(&tx, nIn, txout.nValue);
     SignatureExtractorChecker extractor_checker(data, tx_checker);
     if (VerifyScript(data.scriptSig, txout.scriptPubKey,
                      STANDARD_SCRIPT_VERIFY_FLAGS, extractor_checker)) {
         data.complete = true;
         return data;
     }
 
     // Get scripts
     std::vector<std::vector<uint8_t>> solutions;
     txnouttype script_type = Solver(txout.scriptPubKey, solutions);
     CScript next_script = txout.scriptPubKey;
 
     if (script_type == TX_SCRIPTHASH && !stack.script.empty() &&
         !stack.script.back().empty()) {
         // Get the redeemScript
         CScript redeem_script(stack.script.back().begin(),
                               stack.script.back().end());
         data.redeem_script = redeem_script;
         next_script = std::move(redeem_script);
 
         // Get redeemScript type
         script_type = Solver(next_script, solutions);
         stack.script.pop_back();
     }
     if (script_type == TX_MULTISIG && !stack.script.empty()) {
         // Build a map of pubkey -> signature by matching sigs to pubkeys:
         assert(solutions.size() > 1);
         unsigned int num_pubkeys = solutions.size() - 2;
         unsigned int last_success_key = 0;
         for (const valtype &sig : stack.script) {
             for (unsigned int i = last_success_key; i < num_pubkeys; ++i) {
                 const valtype &pubkey = solutions[i + 1];
                 // We either have a signature for this pubkey, or we have found
                 // a signature and it is valid
                 if (data.signatures.count(CPubKey(pubkey).GetID()) ||
                     extractor_checker.CheckSig(sig, pubkey, next_script,
                                                STANDARD_SCRIPT_VERIFY_FLAGS)) {
                     last_success_key = i + 1;
                     break;
                 }
             }
         }
     }
 
     return data;
 }
 
 void UpdateInput(CTxIn &input, const SignatureData &data) {
     input.scriptSig = data.scriptSig;
 }
 
 void SignatureData::MergeSignatureData(SignatureData sigdata) {
     if (complete) {
         return;
     }
     if (sigdata.complete) {
         *this = std::move(sigdata);
         return;
     }
     if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
         redeem_script = sigdata.redeem_script;
     }
     signatures.insert(std::make_move_iterator(sigdata.signatures.begin()),
                       std::make_move_iterator(sigdata.signatures.end()));
 }
 
 bool SignSignature(const SigningProvider &provider, const CScript &fromPubKey,
                    CMutableTransaction &txTo, unsigned int nIn,
                    const Amount amount, SigHashType sigHashType) {
     assert(nIn < txTo.vin.size());
 
     MutableTransactionSignatureCreator creator(&txTo, nIn, amount, sigHashType);
 
     SignatureData sigdata;
     bool ret = ProduceSignature(provider, creator, fromPubKey, sigdata);
     UpdateInput(txTo.vin.at(nIn), sigdata);
     return ret;
 }
 
 bool SignSignature(const SigningProvider &provider, const CTransaction &txFrom,
                    CMutableTransaction &txTo, unsigned int nIn,
                    SigHashType sigHashType) {
     assert(nIn < txTo.vin.size());
     CTxIn &txin = txTo.vin[nIn];
     assert(txin.prevout.GetN() < txFrom.vout.size());
     const CTxOut &txout = txFrom.vout[txin.prevout.GetN()];
 
     return SignSignature(provider, txout.scriptPubKey, txTo, nIn, txout.nValue,
                          sigHashType);
 }
 
 namespace {
 /** Dummy signature checker which accepts all signatures. */
 class DummySignatureChecker final : public BaseSignatureChecker {
 public:
     DummySignatureChecker() {}
     bool CheckSig(const std::vector<uint8_t> &scriptSig,
                   const std::vector<uint8_t> &vchPubKey,
                   const CScript &scriptCode, uint32_t flags) const override {
         return true;
     }
 };
 const DummySignatureChecker DUMMY_CHECKER;
 
 class DummySignatureCreator final : public BaseSignatureCreator {
 private:
     char m_r_len = 32;
     char m_s_len = 32;
 
 public:
     DummySignatureCreator(char r_len, char s_len)
         : m_r_len(r_len), m_s_len(s_len) {}
     const BaseSignatureChecker &Checker() const override {
         return DUMMY_CHECKER;
     }
     bool CreateSig(const SigningProvider &provider,
                    std::vector<uint8_t> &vchSig, const CKeyID &keyid,
                    const CScript &scriptCode) const override {
         // Create a dummy signature that is a valid DER-encoding
         vchSig.assign(m_r_len + m_s_len + 7, '\000');
         vchSig[0] = 0x30;
         vchSig[1] = m_r_len + m_s_len + 4;
         vchSig[2] = 0x02;
         vchSig[3] = m_r_len;
         vchSig[4] = 0x01;
         vchSig[4 + m_r_len] = 0x02;
         vchSig[5 + m_r_len] = m_s_len;
         vchSig[6 + m_r_len] = 0x01;
         vchSig[6 + m_r_len + m_s_len] = SIGHASH_ALL | SIGHASH_FORKID;
         return true;
     }
 };
 
 template <typename M, typename K, typename V>
 bool LookupHelper(const M &map, const K &key, V &value) {
     auto it = map.find(key);
     if (it != map.end()) {
         value = it->second;
         return true;
     }
     return false;
 }
 
 } // namespace
 
 const BaseSignatureCreator &DUMMY_SIGNATURE_CREATOR =
     DummySignatureCreator(32, 32);
 const BaseSignatureCreator &DUMMY_MAXIMUM_SIGNATURE_CREATOR =
     DummySignatureCreator(33, 32);
 const SigningProvider &DUMMY_SIGNING_PROVIDER = SigningProvider();
 
 bool HidingSigningProvider::GetCScript(const CScriptID &scriptid,
                                        CScript &script) const {
     return m_provider->GetCScript(scriptid, script);
 }
 
 bool HidingSigningProvider::GetPubKey(const CKeyID &keyid,
                                       CPubKey &pubkey) const {
     return m_provider->GetPubKey(keyid, pubkey);
 }
 
 bool HidingSigningProvider::GetKey(const CKeyID &keyid, CKey &key) const {
     if (m_hide_secret) {
         return false;
     }
     return m_provider->GetKey(keyid, key);
 }
 
 bool HidingSigningProvider::GetKeyOrigin(const CKeyID &keyid,
                                          KeyOriginInfo &info) const {
     if (m_hide_origin) {
         return false;
     }
     return m_provider->GetKeyOrigin(keyid, info);
 }
 
 bool FlatSigningProvider::GetCScript(const CScriptID &scriptid,
                                      CScript &script) const {
     return LookupHelper(scripts, scriptid, script);
 }
 bool FlatSigningProvider::GetPubKey(const CKeyID &keyid,
                                     CPubKey &pubkey) const {
     return LookupHelper(pubkeys, keyid, pubkey);
 }
 bool FlatSigningProvider::GetKeyOrigin(const CKeyID &keyid,
                                        KeyOriginInfo &info) const {
     return LookupHelper(origins, keyid, info);
 }
 bool FlatSigningProvider::GetKey(const CKeyID &keyid, CKey &key) const {
     return LookupHelper(keys, keyid, key);
 }
 
 FlatSigningProvider Merge(const FlatSigningProvider &a,
                           const FlatSigningProvider &b) {
     FlatSigningProvider ret;
     ret.scripts = a.scripts;
     ret.scripts.insert(b.scripts.begin(), b.scripts.end());
     ret.pubkeys = a.pubkeys;
     ret.pubkeys.insert(b.pubkeys.begin(), b.pubkeys.end());
     ret.keys = a.keys;
     ret.keys.insert(b.keys.begin(), b.keys.end());
+    ret.origins = a.origins;
+    ret.origins.insert(b.origins.begin(), b.origins.end());
     return ret;
 }
 
 bool IsSolvable(const SigningProvider &provider, const CScript &script) {
     // This check is to make sure that the script we created can actually be
     // solved for and signed by us if we were to have the private keys. This is
     // just to make sure that the script is valid and that, if found in a
     // transaction, we would still accept and relay that transaction.
     SignatureData sigs;
     if (ProduceSignature(provider, DUMMY_SIGNATURE_CREATOR, script, sigs)) {
         // VerifyScript check is just defensive, and should never fail.
         bool verified =
             VerifyScript(sigs.scriptSig, script, STANDARD_SCRIPT_VERIFY_FLAGS,
                          DUMMY_CHECKER);
         assert(verified);
         return true;
     }
     return false;
 }