diff --git a/src/key_io.cpp b/src/key_io.cpp
index cd41a9354994c..1bf36b52345dd 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -56,6 +56,14 @@ class DestinationEncoder : public boost::static_visitor<std::string>
         return bech32::Encode(m_params.Bech32HRP(), data);
     }
 
+    std::string operator()(const WitnessV1Point& id) const
+    {
+        std::vector<unsigned char> data = {1};
+        data.reserve(53);
+        ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
+        return bech32::Encode(m_params.Bech32HRP(), data);
+    }
+
     std::string operator()(const WitnessUnknown& id) const
     {
         if (id.version < 1 || id.version > 16 || id.length < 2 || id.length > 40) {
diff --git a/src/pubkey.cpp b/src/pubkey.cpp
index 5bb0d1a527e13..b441484ec47d6 100644
--- a/src/pubkey.cpp
+++ b/src/pubkey.cpp
@@ -295,6 +295,20 @@ bool CPubKey::CheckPayToContract(const CPubKey& base, const uint256& hash) const
     return memcmp(out, vch, COMPRESSED_PUBLIC_KEY_SIZE) == 0;
 }
 
+bool CPubKey::CreatePayToContract(CPubKey& res, const uint256& hash) const
+{
+    if (!IsCompressed()) return false;
+    secp256k1_pubkey base_point;
+    if (!secp256k1_ec_pubkey_parse(secp256k1_context_verify, &base_point, vch, size())) return false;
+    if (!secp256k1_ec_pubkey_tweak_add(secp256k1_context_verify, &base_point, hash.begin())) return false;
+
+    size_t tweaked_len = COMPRESSED_PUBLIC_KEY_SIZE;
+    unsigned char tweaked[tweaked_len];
+    secp256k1_ec_pubkey_serialize(secp256k1_context_verify, tweaked, &tweaked_len, &base_point, SECP256K1_EC_COMPRESSED);
+    res.Set(tweaked, tweaked + tweaked_len);
+    return true;
+}
+
 /* static */ bool CPubKey::CheckLowS(const std::vector<unsigned char>& vchSig) {
     secp256k1_ecdsa_signature sig;
     if (!ecdsa_signature_parse_der_lax(secp256k1_context_verify, &sig, vchSig.data(), vchSig.size())) {
diff --git a/src/pubkey.h b/src/pubkey.h
index d102e5be8ec7e..38698f2374c32 100644
--- a/src/pubkey.h
+++ b/src/pubkey.h
@@ -209,6 +209,8 @@ class CPubKey
 
     //! Verify a P2C derivation. Hash must be a cryptographic hash that commits to base.
     bool CheckPayToContract(const CPubKey& base, const uint256& hash) const;
+
+    bool CreatePayToContract(CPubKey& res, const uint256& hash) const;
 };
 
 struct CExtPubKey {
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 22d67c34daee9..53ae80fd2be7f 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -233,6 +233,16 @@ class DescribeAddressVisitor : public boost::static_visitor<UniValue>
         return obj;
     }
 
+    UniValue operator()(const WitnessV1Point& id) const
+    {
+        //TODO: What other data should be here?
+        UniValue obj(UniValue::VOBJ);
+        obj.pushKV("iswitness", true);
+        obj.pushKV("witness_version", 1);
+        obj.pushKV("witness_program", HexStr(id.begin(), id.end()));
+        return obj;
+    }
+
     UniValue operator()(const WitnessUnknown& id) const
     {
         UniValue obj(UniValue::VOBJ);
diff --git a/src/script/binarytree.h b/src/script/binarytree.h
new file mode 100644
index 0000000000000..4bc5d696bea66
--- /dev/null
+++ b/src/script/binarytree.h
@@ -0,0 +1,110 @@
+// 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.
+
+
+#ifndef BITCOIN_BINARYTREE_H
+#define BITCOIN_BINARYTREE_H
+
+
+#include <script/script.h>
+#include <util/memory.h>
+#include <memory>
+
+
+template <typename T>
+class BinaryTree
+{
+protected:
+    BinaryTree* parent = nullptr;
+    std::unique_ptr<BinaryTree> left = nullptr;
+    std::unique_ptr<BinaryTree> right = nullptr;
+    std::unique_ptr<T> obj = nullptr;
+
+public:
+    bool IsRoot() const { return parent == nullptr; }
+    bool IsLeaf() const { return obj != nullptr; }
+    bool IsNode() const { return !IsLeaf(); }
+    bool IsEmpty() const { return !left && !right && !IsLeaf(); }
+    bool IsFull() const { return (left && right) || IsLeaf(); }
+
+    const T* GetObj() const
+    {
+        if (!IsLeaf()) return nullptr;
+        return obj.get();
+    }
+
+    bool InsertLeaf(std::unique_ptr<T> sc)
+    {
+        if (!IsEmpty()) return false;
+        if (!sc) return false;
+        obj = std::move(sc);
+        return true;
+    }
+    bool InsertRight(BinaryTree child)
+    {
+        if (right) return false;
+        child.parent = this;
+        right = MakeUnique<BinaryTree>(std::move(child));
+        return true;
+    }
+    bool InsertLeft(BinaryTree child)
+    {
+        if (left) return false;
+        child.parent = this;
+        left = MakeUnique<BinaryTree>(std::move(child));
+        return true;
+    }
+    BinaryTree* GetInitLeftChild()
+    {
+        if (IsLeaf()) return nullptr;
+        if (!left) left = MakeUnique<BinaryTree>(this);
+        return left.get();
+    }
+    BinaryTree* GetInitRightChild()
+    {
+        if (!IsNode()) return nullptr;
+        if (!right) right = MakeUnique<BinaryTree>(BinaryTree(this));
+        return right.get();
+    }
+
+    BinaryTree* GetInitRightSibling()
+    {
+        if (!parent) return nullptr;
+        if (!parent->right) parent->right = MakeUnique<BinaryTree>(BinaryTree(parent));
+        if ((&*parent->right) == this) return nullptr;
+        return parent->right.get();
+    }
+    BinaryTree* GetInitLeftSibling()
+    {
+        if (!parent) return nullptr;
+        if (!parent->left) parent->left = MakeUnique<BinaryTree>(BinaryTree(parent));
+        return parent->left.get();
+    }
+
+    bool RemoveLeftChild()
+    {
+        if (!left) return false;
+        left.reset();
+        return true;
+    }
+
+    std::unique_ptr<T> ReplaceLeaf(std::unique_ptr<T> sc)
+    {
+        obj.swap(sc);
+        return sc;
+    }
+
+    BinaryTree* GetRawRightChild() const { return right.get(); }
+    BinaryTree* GetRawLeftChild() const { return left.get(); }
+    BinaryTree* GetParent() const { return parent; }
+
+    explicit BinaryTree() = default;
+    explicit BinaryTree(T sc) {obj = MakeUnique(std::move(sc));}
+    explicit BinaryTree(std::unique_ptr<T> sc) {obj = std::move(sc);}
+    explicit BinaryTree(BinaryTree* par) {parent = par;}
+
+};
+
+
+#endif
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index b782ebbd1f368..96c9515fa3145 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -13,7 +13,7 @@
 #include <util/bip32.h>
 #include <util/system.h>
 #include <util/strencodings.h>
-
+#include <util/memory.h>
 #include <memory>
 #include <string>
 #include <vector>
@@ -343,6 +343,9 @@ class DescriptorImpl : public Descriptor
     const std::unique_ptr<DescriptorImpl> m_subdescriptor_arg;
     //! The string name of the descriptor function.
     const std::string m_name;
+    //! A binary tree that represents the taproot structure (nullptr for everything else).
+    typedef BinaryTree<DescriptorImpl> TaprootTree;
+    const std::unique_ptr<TaprootTree> m_taproot;
 
 protected:
     //! Return a serialization of anything except pubkey and script arguments, to be prepended to those.
@@ -359,13 +362,59 @@ class DescriptorImpl : public Descriptor
      *             The script arguments to this function are automatically added, as is the origin info of the provided pubkeys.
      *  @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;
+    virtual std::vector<CScript> MakeScripts(const std::vector<CPubKey>& pubkeys, const CScript* script, const BinaryTree<CScript>* taproot, FlatSigningProvider& out) const = 0;
+
+    void ToStringTaprootHelper(const SigningProvider* arg, std::string& out, bool priv, const TaprootTree* tap) const
+    {
+        if (!tap) return;
+        if (tap->IsLeaf()) {
+            std::string tmp;
+            tap->GetObj()->ToStringHelper(arg, tmp, priv);
+            out += tmp;
+            return;
+        }
+        out.push_back('{');
+        ToStringTaprootHelper(arg, out, priv, tap->GetRawLeftChild());
+        out.push_back(',');
+        ToStringTaprootHelper(arg, out, priv, tap->GetRawRightChild());
+        out.push_back('}');
+    }
+
+    bool ToScriptTreeHelper(const SigningProvider& arg, std::vector<CPubKey>& pubkeys, FlatSigningProvider& out, BinaryTree<CScript>* script_root, const TaprootTree* desc_root) const
+    {
+        if (!desc_root || !script_root) return false;
+        if (desc_root->IsLeaf()) {
+            // TODO: Cache? and what should the position be exactly?.
+            std::vector<CScript> script;
+            FlatSigningProvider subprovider;
+            if(!desc_root->GetObj()->Expand(0, arg, script, subprovider)) return false;
+            out = Merge(out, subprovider);
+            return script_root->InsertLeaf(std::move(MakeUnique<CScript>(script[0])));
+        }
+        if(!ToScriptTreeHelper(arg, pubkeys, out, script_root->GetInitLeftChild(), desc_root->GetRawLeftChild())) return false;
+        return ToScriptTreeHelper(arg, pubkeys, out, script_root->GetInitRightChild(), desc_root->GetRawRightChild());
+    }
+
+    void ExpandPrivateTreeHelper(const SigningProvider& provider, FlatSigningProvider& out, TaprootTree* desc_root) const
+    {
+        if (!desc_root) return;
+        if (desc_root->IsLeaf()) {
+            // TODO: Position?
+            FlatSigningProvider subprovider;
+            desc_root->GetObj()->ExpandPrivate(0, provider, subprovider);
+            out = Merge(out, subprovider);
+            return;
+        }
+        ExpandPrivateTreeHelper(provider, out, desc_root->GetRawLeftChild());
+        ExpandPrivateTreeHelper(provider, out, desc_root->GetRawRightChild());
+    }
 
 public:
-    DescriptorImpl(std::vector<std::unique_ptr<PubkeyProvider>> pubkeys, std::unique_ptr<DescriptorImpl> script, const std::string& name) : m_pubkey_args(std::move(pubkeys)), m_subdescriptor_arg(std::move(script)), m_name(name) {}
+    DescriptorImpl(std::vector<std::unique_ptr<PubkeyProvider>> pubkeys, std::unique_ptr<DescriptorImpl> script, std::unique_ptr<TaprootTree> taproot, const std::string& name) : m_pubkey_args(std::move(pubkeys)), m_subdescriptor_arg(std::move(script)), m_taproot(std::move(taproot)), m_name(name) {}
 
     bool IsSolvable() const override
     {
+        // TODO: Add taproot exception.
         if (m_subdescriptor_arg) {
             if (!m_subdescriptor_arg->IsSolvable()) return false;
         }
@@ -404,6 +453,10 @@ class DescriptorImpl : public Descriptor
             if (!m_subdescriptor_arg->ToStringHelper(arg, tmp, priv)) return false;
             ret += std::move(tmp);
         }
+        if (m_taproot) {
+            ret += ",";
+            ToStringTaprootHelper(arg, ret, priv, m_taproot.get());
+        }
         out = std::move(ret) + ")";
         return true;
     }
@@ -463,13 +516,17 @@ class DescriptorImpl : public Descriptor
         if (m_subdescriptor_arg) {
             for (const auto& subscript : subscripts) {
                 out.scripts.emplace(CScriptID(subscript), subscript);
-                std::vector<CScript> addscripts = MakeScripts(pubkeys, &subscript, out);
+                std::vector<CScript> addscripts = MakeScripts(pubkeys, &subscript, nullptr, out);
                 for (auto& addscript : addscripts) {
                     output_scripts.push_back(std::move(addscript));
                 }
             }
+        } else if (m_taproot) {
+            BinaryTree<CScript> scripted_taproot;
+            if(!ToScriptTreeHelper(arg, pubkeys, out, &scripted_taproot, m_taproot.get())) return false;
+            output_scripts = MakeScripts(pubkeys, nullptr, &scripted_taproot, out);
         } else {
-            output_scripts = MakeScripts(pubkeys, nullptr, out);
+            output_scripts = MakeScripts(pubkeys, nullptr, nullptr, out);
         }
         return true;
     }
@@ -497,6 +554,11 @@ class DescriptorImpl : public Descriptor
             m_subdescriptor_arg->ExpandPrivate(pos, provider, subprovider);
             out = Merge(out, subprovider);
         }
+        if (m_taproot) {
+            FlatSigningProvider subprovider;
+            ExpandPrivateTreeHelper(provider, subprovider, m_taproot.get());
+            out = Merge(out, subprovider);
+        }
     }
 };
 
@@ -515,9 +577,9 @@ class AddressDescriptor final : public DescriptorImpl
     const CTxDestination m_destination;
 protected:
     std::string ToStringExtra() const override { return EncodeDestination(m_destination); }
-    std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, const CScript*, FlatSigningProvider&) const override { return Singleton(GetScriptForDestination(m_destination)); }
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, const CScript*, const BinaryTree<CScript>*, FlatSigningProvider&) const override { return Singleton(GetScriptForDestination(m_destination)); }
 public:
-    AddressDescriptor(CTxDestination destination) : DescriptorImpl({}, {}, "addr"), m_destination(std::move(destination)) {}
+    AddressDescriptor(CTxDestination destination) : DescriptorImpl({}, {}, {}, "addr"), m_destination(std::move(destination)) {}
     bool IsSolvable() const final { return false; }
 };
 
@@ -527,9 +589,9 @@ class RawDescriptor final : public DescriptorImpl
     const CScript m_script;
 protected:
     std::string ToStringExtra() const override { return HexStr(m_script.begin(), m_script.end()); }
-    std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, const CScript*, FlatSigningProvider&) const override { return Singleton(m_script); }
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, const CScript*, const BinaryTree<CScript>*, FlatSigningProvider&) const override { return Singleton(m_script); }
 public:
-    RawDescriptor(CScript script) : DescriptorImpl({}, {}, "raw"), m_script(std::move(script)) {}
+    RawDescriptor(CScript script) : DescriptorImpl({}, {}, {}, "raw"), m_script(std::move(script)) {}
     bool IsSolvable() const final { return false; }
 };
 
@@ -537,44 +599,44 @@ class RawDescriptor final : public DescriptorImpl
 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])); }
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, const BinaryTree<CScript>*, FlatSigningProvider&) const override { return Singleton(GetScriptForRawPubKey(keys[0])); }
 public:
-    PKDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, "pk") {}
+    PKDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, {}, "pk") {}
 };
 
 /** A parsed pkh(P) descriptor. */
 class PKHDescriptor final : public DescriptorImpl
 {
 protected:
-    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, FlatSigningProvider& out) const override
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, const BinaryTree<CScript>*, FlatSigningProvider& out) const override
     {
         CKeyID id = keys[0].GetID();
         out.pubkeys.emplace(id, keys[0]);
         return Singleton(GetScriptForDestination(PKHash(id)));
     }
 public:
-    PKHDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, "pkh") {}
+    PKHDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, {}, "pkh") {}
 };
 
 /** A parsed wpkh(P) descriptor. */
 class WPKHDescriptor final : public DescriptorImpl
 {
 protected:
-    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, FlatSigningProvider& out) const override
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, const BinaryTree<CScript>*, FlatSigningProvider& out) const override
     {
         CKeyID id = keys[0].GetID();
         out.pubkeys.emplace(id, keys[0]);
         return Singleton(GetScriptForDestination(WitnessV0KeyHash(id)));
     }
 public:
-    WPKHDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, "wpkh") {}
+    WPKHDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, {}, "wpkh") {}
 };
 
 /** A parsed combo(P) descriptor. */
 class ComboDescriptor final : public DescriptorImpl
 {
 protected:
-    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, FlatSigningProvider& out) const override
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, const BinaryTree<CScript>*, FlatSigningProvider& out) const override
     {
         std::vector<CScript> ret;
         CKeyID id = keys[0].GetID();
@@ -590,7 +652,7 @@ class ComboDescriptor final : public DescriptorImpl
         return ret;
     }
 public:
-    ComboDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, "combo") {}
+    ComboDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, {}, "combo") {}
 };
 
 /** A parsed multi(...) descriptor. */
@@ -599,29 +661,110 @@ class MultisigDescriptor final : public DescriptorImpl
     const int m_threshold;
 protected:
     std::string ToStringExtra() const override { return strprintf("%i", m_threshold); }
-    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, FlatSigningProvider&) const override { return Singleton(GetScriptForMultisig(m_threshold, keys)); }
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript*, const BinaryTree<CScript>*, FlatSigningProvider&) const override { return Singleton(GetScriptForMultisig(m_threshold, keys)); }
 public:
-    MultisigDescriptor(int threshold, std::vector<std::unique_ptr<PubkeyProvider>> providers) : DescriptorImpl(std::move(providers), {}, "multi"), m_threshold(threshold) {}
+    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(ScriptHash(*script))); }
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, const CScript* script, const BinaryTree<CScript>*, FlatSigningProvider&) const override { return Singleton(GetScriptForDestination(ScriptHash(*script))); }
 public:
-    SHDescriptor(std::unique_ptr<DescriptorImpl> desc) : DescriptorImpl({}, std::move(desc), "sh") {}
+    SHDescriptor(std::unique_ptr<DescriptorImpl> desc) : DescriptorImpl({}, std::move(desc), {}, "sh") {}
 };
 
 /** A parsed wsh(...) descriptor. */
 class WSHDescriptor final : public DescriptorImpl
 {
 protected:
-    std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, const CScript* script, FlatSigningProvider&) const override { return Singleton(GetScriptForDestination(WitnessV0ScriptHash(*script))); }
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey>&, const CScript* script, const BinaryTree<CScript>*, FlatSigningProvider&) const override { return Singleton(GetScriptForDestination(WitnessV0ScriptHash(*script))); }
+public:
+    WSHDescriptor(std::unique_ptr<DescriptorImpl> desc) : DescriptorImpl({}, std::move(desc), {}, "wsh") {}
+};
+
+// This is copied from `interpreter.cpp`, with the hope that when taproot PR is open this code will move to script.h or some other common header.
+static CHashWriter TaggedHash(const std::string& tag)
+{
+    CHashWriter writer(SER_GETHASH, 0);
+    uint256 taghash;
+    CSHA256().Write((unsigned char*)tag.data(), tag.size()).Finalize(taghash.begin());
+    writer << taghash << taghash;
+    return writer;
+}
+
+static const CHashWriter HasherTapLeaf = TaggedHash("TapLeaf");
+static const CHashWriter HasherTapBranch = TaggedHash("TapBranch");
+static const CHashWriter HasherTapTweak = TaggedHash("TapTweak");
+
+typedef BinaryTree<DescriptorImpl> TaprootTree;
+class TapDescriptor final : public DescriptorImpl
+{
+
+protected:
+
+    std::vector<ScriptPath> ConstructScriptPathsHelper(const BinaryTree<CScript>& tap, uint256& curr_hash) const {
+        if (tap.IsEmpty()) throw std::runtime_error("Got a partial binary tree"); // Should never happen.
+        if (tap.IsLeaf()) {
+            ScriptPath ret;
+            ret.leaf = *tap.GetObj();
+            CHashWriter leaf_hash = HasherTapLeaf;
+            leaf_hash << ret.version << ret.leaf;
+            curr_hash =  leaf_hash.GetSHA256();
+            return std::vector<ScriptPath>{ret};
+        }
+        if (!tap.GetRawRightChild() || !tap.GetRawLeftChild()) throw std::runtime_error("WTFFF");
+
+        uint256 right_hash;
+        uint256 left_hash;
+        std::vector<ScriptPath> right = ConstructScriptPathsHelper(*tap.GetRawRightChild(), right_hash);
+        std::vector<ScriptPath> left = ConstructScriptPathsHelper(*tap.GetRawLeftChild(), left_hash);
+
+        CHashWriter branch = HasherTapBranch;
+        if (std::lexicographical_compare(left_hash.begin(), left_hash.end(), right_hash.begin(), right_hash.end())) {
+            branch << left_hash << right_hash;
+        } else {
+            branch << right_hash << left_hash;
+        }
+        curr_hash = branch.GetSHA256();
+        for (ScriptPath& path : right) path.path.push_back(left_hash);
+        for (ScriptPath& path : left) path.path.push_back(right_hash);
+
+        right.reserve(left.size());
+        right.insert(right.end(), left.begin(), left.end());
+
+        return right;
+    }
+
+    std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, const CScript* s, const BinaryTree<CScript>* tree, FlatSigningProvider& out) const override {
+        CPubKey pubkey{keys[0]};
+        if (tree) {
+            uint256 root_hash;
+            std::vector<ScriptPath> paths = ConstructScriptPathsHelper(*tree, root_hash);
+            CHashWriter tweak = HasherTapTweak;
+            tweak << MakeSpan(pubkey) << root_hash;
+            uint256 hashed_tweak = tweak.GetSHA256();
+            CPubKey tweaked;
+            pubkey.CreatePayToContract(tweaked, hashed_tweak);
+
+            out.p2c_tweaks.emplace(tweaked.GetID(), std::make_pair(pubkey, hashed_tweak));
+            out.taproot_paths.emplace(tweaked.GetID(), std::move(paths));
+            pubkey = tweaked;
+        }
+        // TODO: Look into where is the *spending script generated*.
+        // TODO: Add all the needed unit tests :).
+        return Singleton(GetScriptForDestination(WitnessV1Point(pubkey)));
+    }
 public:
-    WSHDescriptor(std::unique_ptr<DescriptorImpl> desc) : DescriptorImpl({}, std::move(desc), "wsh") {}
+
+    bool IsSolvable() const final { return true; }
+    TapDescriptor(std::unique_ptr<PubkeyProvider> prov) : DescriptorImpl(Singleton(std::move(prov)), {}, {}, "tap") {}
+    TapDescriptor(std::unique_ptr<PubkeyProvider> prov, std::unique_ptr<BinaryTree<DescriptorImpl>> taproot) : DescriptorImpl(Singleton(std::move(prov)), {}, std::move(taproot), "tap") {}
 };
 
+
+
 ////////////////////////////////////////////////////////////////////////////
 // Parser                                                                 //
 ////////////////////////////////////////////////////////////////////////////
@@ -630,8 +773,11 @@ enum class ParseScriptContext {
     TOP,
     P2SH,
     P2WSH,
+    Tap,
 };
 
+std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptContext ctx, FlatSigningProvider& out, std::string& error);
+
 /** 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)
 {
@@ -689,6 +835,20 @@ std::vector<Span<const char>> Split(const Span<const char>& sp, char sep)
     return ret;
 }
 
+/** Split a string at the first instance of sep, returning a pair. */
+std::pair<Span<const char>, Span<const char>> SplitOnce(const Span<const char>& sp, char sep)
+{
+    auto it = sp.begin();
+    auto start = it;
+    while (it != sp.end()) {
+        if (*it == sep) {
+            return std::make_pair(Span<const char>(start, it), Span<const char>(it + 1, sp.end()));
+        }
+        ++it;
+    }
+    return std::make_pair(Span<const char>(start, sp.end()), Span<const char>(sp.end(), sp.end()));
+}
+
 /** 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, std::string& error)
 {
@@ -805,17 +965,81 @@ std::unique_ptr<PubkeyProvider> ParsePubkey(const Span<const char>& sp, bool per
     return MakeUnique<OriginPubkeyProvider>(std::move(info), std::move(provider));
 }
 
+bool InsertTaproot(const Span<const char>& sp, TaprootTree* node, FlatSigningProvider& out, std::string& error)
+{
+    if (!node) return false;
+
+    auto it = sp.begin();
+    while (it != sp.end()) {
+        switch(*it) {
+        case '{':
+            return InsertTaproot(Span<const char>(it+1, sp.end()), node->GetInitLeftChild(), out, error);
+        case ',': {
+            if (*(it-1) == ')') {
+                auto desc_sp = Span<const char>(sp.begin(), it);
+                std::unique_ptr<DescriptorImpl> desc = ParseScript(desc_sp, ParseScriptContext::Tap, out, error);
+                if(!desc || !node->InsertLeaf(std::move(desc))) {
+                    if (error.empty()) error = "Too many leafs on the same level";
+                    return false;
+                }
+            }
+            return InsertTaproot(Span<const char>(it+1, sp.end()), node->GetInitRightSibling(), out, error);
+        }
+        case '}': {
+            if (*(it-1) == ')') {
+                auto desc_sp = Span<const char>(sp.begin(), it);
+                std::unique_ptr<DescriptorImpl> desc = ParseScript(desc_sp, ParseScriptContext::Tap, out, error);
+                if(!desc || !node->InsertLeaf(std::move(desc))) {
+                    if (error.empty()) error = "Too many leafs on the same level";
+                    return false;
+                }
+            }
+            auto parent = node->GetParent();
+            if (!parent) {
+                error = "Too many '{'";
+                return false;
+            } else if (!parent->IsFull()) {
+                error = "Missing leafs";
+                return false;
+            }
+            return InsertTaproot(Span<const char>(it+1, sp.end()), parent, out, error);
+        }
+        }
+        ++it;
+    }
+    if (node->IsRoot() && node->IsEmpty()) {
+        auto desc_sp = Span<const char>(sp.begin(), it);
+        std::unique_ptr<DescriptorImpl> desc = ParseScript(desc_sp, ParseScriptContext::Tap, out, error);
+        if(!desc || !node->InsertLeaf(std::move(desc))) {
+            if (error.empty()) error = "Too many leafs on the same level";
+            return false;
+        }
+    }
+    return true;
+}
+
+/** Parse a taproot descriptor */
+std::unique_ptr<TapDescriptor> ParseTaproot(const Span<const char>& sp, std::unique_ptr<PubkeyProvider> internal_key, FlatSigningProvider& out, std::string& error)
+{
+    if (sp.size() == 0) return MakeUnique<TapDescriptor>(std::move(internal_key));
+//    if ((*sp.begin() != '{') || (*(sp.end()-1) != '}')) return nullptr;
+
+    auto root = MakeUnique<TaprootTree>(TaprootTree());
+    if(!InsertTaproot(sp, root.get(), out, error)) return nullptr;
+
+    return MakeUnique<TapDescriptor>(std::move(internal_key), std::move(root));
+}
 /** Parse a script in a particular context. */
 std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptContext ctx, FlatSigningProvider& out, std::string& error)
 {
     auto expr = Expr(sp);
     if (Func("pk", expr)) {
-        auto pubkey = ParsePubkey(expr, ctx != ParseScriptContext::P2WSH, out, error);
+        auto pubkey = ParsePubkey(expr, (ctx != ParseScriptContext::P2WSH && ctx != ParseScriptContext::Tap), out, error);
         if (!pubkey) return nullptr;
         return MakeUnique<PKDescriptor>(std::move(pubkey));
     }
     if (Func("pkh", expr)) {
-        auto pubkey = ParsePubkey(expr, ctx != ParseScriptContext::P2WSH, out, error);
+        auto pubkey = ParsePubkey(expr, (ctx != ParseScriptContext::P2WSH && ctx != ParseScriptContext::Tap), out, error);
         if (!pubkey) return nullptr;
         return MakeUnique<PKHDescriptor>(std::move(pubkey));
     }
@@ -827,7 +1051,7 @@ std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptCon
         error = "Cannot have combo in non-top level";
         return nullptr;
     }
-    if (Func("multi", expr)) {
+    if (ctx != ParseScriptContext::Tap && Func("multi", expr)) {
         auto threshold = Expr(expr);
         uint32_t thres;
         std::vector<std::unique_ptr<PubkeyProvider>> providers;
@@ -871,7 +1095,7 @@ std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptCon
         }
         return MakeUnique<MultisigDescriptor>(thres, std::move(providers));
     }
-    if (ctx != ParseScriptContext::P2WSH && Func("wpkh", expr)) {
+    if (ctx != ParseScriptContext::P2WSH && ctx != ParseScriptContext::Tap && Func("wpkh", expr)) {
         auto pubkey = ParsePubkey(expr, false, out, error);
         if (!pubkey) return nullptr;
         return MakeUnique<WPKHDescriptor>(std::move(pubkey));
@@ -887,7 +1111,7 @@ std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptCon
         error = "Cannot have sh in non-top level";
         return nullptr;
     }
-    if (ctx != ParseScriptContext::P2WSH && Func("wsh", expr)) {
+    if (ctx != ParseScriptContext::P2WSH && ctx != ParseScriptContext::Tap && Func("wsh", expr)) {
         auto desc = ParseScript(expr, ParseScriptContext::P2WSH, out, error);
         if (!desc || expr.size()) return nullptr;
         return MakeUnique<WSHDescriptor>(std::move(desc));
@@ -912,6 +1136,12 @@ std::unique_ptr<DescriptorImpl> ParseScript(Span<const char>& sp, ParseScriptCon
         auto bytes = ParseHex(str);
         return MakeUnique<RawDescriptor>(CScript(bytes.begin(), bytes.end()));
     }
+    if (ctx == ParseScriptContext::TOP && Func("tap", expr)) {
+        auto key_only = SplitOnce(expr, ',');
+        auto internal_key = ParsePubkey(key_only.first, false, out, error);
+        if (!internal_key) return nullptr;
+        return ParseTaproot(key_only.second, std::move(internal_key), out, error);
+    }
     if (ctx == ParseScriptContext::P2SH) {
         error = "A function is needed within P2SH";
         return nullptr;
@@ -986,6 +1216,54 @@ std::unique_ptr<DescriptorImpl> InferScript(const CScript& script, ParseScriptCo
             if (sub) return MakeUnique<WSHDescriptor>(std::move(sub));
         }
     }
+    if (txntype == TX_WITNESS_V1_TAPROOT && ctx == ParseScriptContext::TOP) {
+        data[0][0]+=2;
+        CPubKey address(data[0]);
+        std::vector<ScriptPath> paths;
+        std::unique_ptr<BinaryTree<DescriptorImpl>> taproot;
+        if(provider.GetScriptPaths(address.GetID(), paths)) {
+            std::list<std::pair<std::vector<uint256>,BinaryTree<DescriptorImpl>>> nodes(paths.size());
+
+
+            std::sort(paths.begin(), paths.end(), [](const ScriptPath& a, const ScriptPath& b){
+                if (a.path.size() == b.path.size()) {
+                    return std::lexicographical_compare(a.path.rbegin(), a.path.rend(), b.path.rbegin(), b.path.rend());
+                } else {
+                    return a.path.size() > b.path.size();
+                }
+            });
+
+            std::transform(paths.begin(), paths.end(), nodes.begin(), [&provider](const ScriptPath& a){
+              std::unique_ptr<DescriptorImpl> script = InferScript(a.leaf, ParseScriptContext::Tap, provider);
+                return std::make_pair(a.path, BinaryTree<DescriptorImpl>(std::move(script)));
+            });
+
+            while (nodes.size() > 1) {
+                auto curr = nodes.begin();
+                while (curr != nodes.end()) {
+                    auto next = std::next(curr);
+                    if (!(curr->first.size() == next->first.size() && std::equal(curr->first.rbegin(), curr->first.rend()-1, next->first.rbegin()))) return nullptr;
+                    BinaryTree<DescriptorImpl> par;
+                    par.InsertLeft(std::move(curr->second)); par.InsertRight(std::move(next->second));
+                    curr->second = std::move(par);
+                    curr->first.erase(curr->first.begin());
+                    nodes.erase(next);
+                    if (curr != nodes.end() && curr->first.size() != std::next(curr)->first.size()) ++curr;
+                }
+            }
+            if (!nodes.back().first.empty()) return nullptr;
+            taproot = MakeUnique<BinaryTree<DescriptorImpl>>(std::move(nodes.back().second));
+        }
+        CPubKey base;
+        uint256 tweak;
+        std::unique_ptr<PubkeyProvider> internal_key;
+        if (provider.GetP2CTweaks(address.GetID(), base, tweak)) {
+            internal_key =  InferPubkey(base, ParseScriptContext::Tap, provider);
+        } else {
+            internal_key = InferPubkey(address, ParseScriptContext::Tap, provider);
+        }
+        return MakeUnique<TapDescriptor>(std::move(internal_key), std::move(taproot));
+    }
 
     CTxDestination dest;
     if (ExtractDestination(script, dest)) {
diff --git a/src/script/descriptor.h b/src/script/descriptor.h
index 0195ca09397f2..463d37f3bff21 100644
--- a/src/script/descriptor.h
+++ b/src/script/descriptor.h
@@ -8,6 +8,7 @@
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
+#include <script/binarytree.h>
 
 #include <vector>
 
diff --git a/src/script/script.h b/src/script/script.h
index b7a2bf1526c4d..1da21cca2aa84 100644
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -59,6 +59,14 @@ std::vector<unsigned char> ToByteVector(const T& in)
     return std::vector<unsigned char>(in.begin(), in.end());
 }
 
+
+template <typename I, typename O>
+void ExtendByteVector(const I& in, std::vector<O>& out)
+{
+    out.reserve(out.size() + in.size());
+    out.insert(out.end(), in.begin(), in.end());
+}
+
 /** Script opcodes */
 enum opcodetype
 {
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index 99da7dd917f52..27eb1a9f3400e 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -168,6 +168,9 @@ static bool SignStep(const SigningProvider& provider, const BaseSignatureCreator
         sigdata.missing_witness_script = uint256(vSolutions[0]);
         return false;
 
+    case TX_WITNESS_V1_TAPROOT:
+        ret.push_back(vSolutions[0]);
+        return true;
     default:
         return false;
     }
@@ -188,6 +191,26 @@ static CScript PushAll(const std::vector<valtype>& values)
     return result;
 }
 
+bool IsTaprootAllowed(txnouttype type) {
+    switch(type)
+    {
+    case TX_WITNESS_V1_TAPROOT:
+    case TX_WITNESS_V0_KEYHASH:
+    case TX_WITNESS_V0_SCRIPTHASH:
+    case TX_SCRIPTHASH:
+    case TX_NULL_DATA:
+    case TX_WITNESS_UNKNOWN:
+        return false;
+
+    case TX_PUBKEY:
+    case TX_PUBKEYHASH:
+    case TX_NONSTANDARD:
+    case TX_MULTISIG:
+        return true;
+    }
+}
+
+
 bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreator& creator, const CScript& fromPubKey, SignatureData& sigdata)
 {
     if (sigdata.complete) return true;
@@ -230,6 +253,50 @@ bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreato
         sigdata.scriptWitness.stack = result;
         sigdata.witness = true;
         result.clear();
+    } else if (solved && whichType == TX_WITNESS_V1_TAPROOT) {
+        std::vector<unsigned char> address_vec(result[0]);
+        address_vec[0] += 2;
+        CPubKey address{address_vec}, base;
+        uint256 tweak;
+        txnouttype sub_type;
+        // First see if we control the point key in the witness program.
+        if (SignStep(provider, creator, (CScript() << address_vec << OP_CHECKSIG), result, sub_type, SigVersion::TAPROOT, sigdata)) {
+        // If not see if the signing provider have a Pay-To-Contract tweak for this key.
+        } else if(provider.GetP2CTweaks(address.GetID(), base, tweak)) {
+            std::vector<unsigned char> base_vec(base.begin(), base.end());
+            std::vector<unsigned char> control_block;
+            std::vector<ScriptPath> paths;
+            sigdata.p2c_tweaks.emplace(base, tweak);
+            base_vec[0] -= 2;
+            // TODO: Should I assume that if I can't sign fo`r the tweaked key then I can't sign for the base key?. if so the next if can be removed.
+            // Check if we're in control with the base key.
+            if (!SignStep(provider, creator, (CScript() << base_vec << OP_CHECKSIG), result, sub_type, SigVersion::TAPROOT, sigdata)) {
+                if(provider.GetScriptPaths(address.GetID(), paths)) {
+                    bool can_sign_any_path = false;
+                    for (auto& path : paths) {
+                        // Check if we can sign for any of the paths scripts.
+                        if (SignStep(provider, creator, path.leaf, result, sub_type, SigVersion::TAPROOT, sigdata) && IsTaprootAllowed(sub_type)) {
+                            ExtendByteVector(base_vec, control_block);
+                            for (auto& hash : path.path) {
+                                ExtendByteVector(hash, control_block);
+                            }
+                            sigdata.taproot_script_path = path;
+                            can_sign_any_path = true;
+                            break; // break out the second we found a script we can sign for.
+                        }
+                    }
+                    solved = solved && can_sign_any_path;
+                } else {
+                    solved = false;
+                }
+                if (!control_block.empty()) result.emplace_back(control_block);
+            }
+        } else {
+            solved = false;
+        }
+        sigdata.witness = true;
+        sigdata.scriptWitness.stack = result;
+        result.clear();
     } else if (solved && whichType == TX_WITNESS_UNKNOWN) {
         sigdata.witness = true;
     }
@@ -238,7 +305,6 @@ bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreato
         result.push_back(std::vector<unsigned char>(subscript.begin(), subscript.end()));
     }
     sigdata.scriptSig = PushAll(result);
-
     // Test solution
     sigdata.complete = solved && VerifyScript(sigdata.scriptSig, fromPubKey, &sigdata.scriptWitness, STANDARD_SCRIPT_VERIFY_FLAGS, creator.Checker());
     return sigdata.complete;
@@ -454,14 +520,25 @@ bool IsSegWitOutput(const SigningProvider& provider, const CScript& script)
 {
     std::vector<valtype> solutions;
     auto whichtype = Solver(script, solutions);
-    if (whichtype == TX_WITNESS_V0_SCRIPTHASH || whichtype == TX_WITNESS_V0_KEYHASH || whichtype == TX_WITNESS_UNKNOWN) return true;
-    if (whichtype == TX_SCRIPTHASH) {
+    switch (whichtype) {
+    case TX_WITNESS_V0_SCRIPTHASH:
+    case TX_WITNESS_V0_KEYHASH:
+    case TX_WITNESS_V1_TAPROOT:
+    case TX_WITNESS_UNKNOWN:
+        return true;
+    case TX_NULL_DATA:
+    case TX_PUBKEY:
+    case TX_PUBKEYHASH:
+    case TX_NONSTANDARD:
+    case TX_MULTISIG:
+        return false;
+    case TX_SCRIPTHASH: {
         auto h160 = uint160(solutions[0]);
         CScript subscript;
-        if (provider.GetCScript(h160, subscript)) {
-            whichtype = Solver(subscript, solutions);
-            if (whichtype == TX_WITNESS_V0_SCRIPTHASH || whichtype == TX_WITNESS_V0_KEYHASH || whichtype == TX_WITNESS_UNKNOWN) return true;
-        }
+        if (provider.GetCScript(h160, subscript))
+            return IsSegWitOutput(provider, subscript);
+        else
+            return false;
+    }
     }
-    return false;
 }
diff --git a/src/script/sign.h b/src/script/sign.h
index 0e751afd3ba5e..ec1a5c58315ca 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -6,6 +6,7 @@
 #ifndef BITCOIN_SCRIPT_SIGN_H
 #define BITCOIN_SCRIPT_SIGN_H
 
+#include "signingprovider.h"
 #include <boost/optional.hpp>
 #include <hash.h>
 #include <pubkey.h>
@@ -62,6 +63,8 @@ struct SignatureData {
     CScript scriptSig; ///< The scriptSig of an input. Contains complete signatures or the traditional partial signatures format
     CScript redeem_script; ///< The redeemScript (if any) for the input
     CScript witness_script; ///< The witnessScript (if any) for the input. witnessScripts are used in P2WSH outputs.
+    ScriptPath taproot_script_path; ///< The (if any) tapscript + merkle path for the control block. This is used in SegwitV1(Taproot) outputs.
+    std::map<CPubKey, uint256> p2c_tweaks; ///< The Pay-To-Contract tweaks (if any), needed to contruct the control block. This is used in SegwitV1(Taproot) outputs
     CScriptWitness scriptWitness; ///< The scriptWitness of an input. Contains complete signatures or the traditional partial signatures format. scriptWitness is part of a transaction input per BIP 144.
     std::map<CKeyID, SigPair> signatures; ///< BIP 174 style partial signatures for the input. May contain all signatures necessary for producing a final scriptSig or scriptWitness.
     std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> misc_pubkeys;
diff --git a/src/script/signingprovider.cpp b/src/script/signingprovider.cpp
index 01757e2f65537..6db7c465f6e07 100644
--- a/src/script/signingprovider.cpp
+++ b/src/script/signingprovider.cpp
@@ -44,6 +44,18 @@ bool HidingSigningProvider::GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& inf
     return m_provider->GetKeyOrigin(keyid, info);
 }
 
+bool HidingSigningProvider::GetScriptPaths(const CKeyID &addressid, std::vector<ScriptPath>& paths) const
+{
+    if (m_hide_origin) return false;
+    return m_provider->GetScriptPaths(addressid, paths);
+}
+
+bool HidingSigningProvider::GetP2CTweaks(const CKeyID &addressid, CPubKey& base, uint256& tweak) const
+{
+    if (m_hide_origin) return false;
+    return m_provider->GetP2CTweaks(addressid, base, tweak);
+}
+
 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
@@ -55,6 +67,21 @@ bool FlatSigningProvider::GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info)
 }
 bool FlatSigningProvider::GetKey(const CKeyID& keyid, CKey& key) const { return LookupHelper(keys, keyid, key); }
 
+
+bool FlatSigningProvider::GetScriptPaths(const CKeyID &addressid, std::vector<ScriptPath>& paths) const { return LookupHelper(taproot_paths, addressid, paths); }
+
+bool FlatSigningProvider::GetP2CTweaks(const CKeyID &addressid, CPubKey& base, uint256& tweak) const
+{
+    std::pair<CPubKey, uint256> out;
+    bool ret = LookupHelper(p2c_tweaks, addressid, out);
+    if(ret) {
+        base = out.first;
+        tweak = out.second;
+    }
+    return ret;
+}
+
+
 FlatSigningProvider Merge(const FlatSigningProvider& a, const FlatSigningProvider& b)
 {
     FlatSigningProvider ret;
diff --git a/src/script/signingprovider.h b/src/script/signingprovider.h
index 4eec2311d4144..2dd308ad728af 100644
--- a/src/script/signingprovider.h
+++ b/src/script/signingprovider.h
@@ -14,6 +14,18 @@
 
 struct KeyOriginInfo;
 
+struct ScriptPath
+{
+    uint8_t version = 0xc0;
+    CScript leaf;
+    std::vector<uint256> path;
+
+    void clear() {
+        leaf.clear();
+        path.clear();
+    }
+};
+
 /** An interface to be implemented by keystores that support signing. */
 class SigningProvider
 {
@@ -25,6 +37,14 @@ class SigningProvider
     virtual bool GetKey(const CKeyID &address, CKey& key) const { return false; }
     virtual bool HaveKey(const CKeyID &address) const { return false; }
     virtual bool GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const { return false; }
+    virtual bool GetScriptPaths(const CKeyID &addressid, std::vector<ScriptPath>& paths) const { return false; }
+    virtual bool GetP2CTweaks(const CKeyID &addressid, CPubKey& base, uint256& tweak) const { return false; }
+
+    SigningProvider() = default;
+protected:
+    // This prevents accidental object slicing.
+    SigningProvider(const SigningProvider&) = default;
+    SigningProvider& operator=(const SigningProvider&) = default;
 };
 
 extern const SigningProvider& DUMMY_SIGNING_PROVIDER;
@@ -42,6 +62,8 @@ class HidingSigningProvider : public SigningProvider
     bool GetPubKey(const CKeyID& keyid, CPubKey& pubkey) const override;
     bool GetKey(const CKeyID& keyid, CKey& key) const override;
     bool GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const override;
+    bool GetScriptPaths(const CKeyID &addressid, std::vector<ScriptPath>& paths) const override;
+    bool GetP2CTweaks(const CKeyID &addressid, CPubKey& base, uint256& tweak) const override;
 };
 
 struct FlatSigningProvider final : public SigningProvider
@@ -50,11 +72,16 @@ struct FlatSigningProvider final : public SigningProvider
     std::map<CKeyID, CPubKey> pubkeys;
     std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> origins;
     std::map<CKeyID, CKey> keys;
+    std::map<CKeyID, std::vector<ScriptPath>> taproot_paths;
+    std::map<CKeyID, std::pair<CPubKey, uint256>> p2c_tweaks;
 
     bool GetCScript(const CScriptID& scriptid, CScript& script) const override;
     bool GetPubKey(const CKeyID& keyid, CPubKey& pubkey) const override;
     bool GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const override;
     bool GetKey(const CKeyID& keyid, CKey& key) const override;
+    bool GetScriptPaths(const CKeyID &addressid, std::vector<ScriptPath>& paths) const override;
+    bool GetP2CTweaks(const CKeyID &addressid, CPubKey& base, uint256& tweak) const override;
+
 };
 
 FlatSigningProvider Merge(const FlatSigningProvider& a, const FlatSigningProvider& b);
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index fc6898f4445c6..8b0628613b34f 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -37,6 +37,7 @@ const char* GetTxnOutputType(txnouttype t)
     case TX_NULL_DATA: return "nulldata";
     case TX_WITNESS_V0_KEYHASH: return "witness_v0_keyhash";
     case TX_WITNESS_V0_SCRIPTHASH: return "witness_v0_scripthash";
+    case TX_WITNESS_V1_TAPROOT: return "witness_v1_taproot";
     case TX_WITNESS_UNKNOWN: return "witness_unknown";
     }
     return nullptr;
@@ -112,6 +113,10 @@ txnouttype Solver(const CScript& scriptPubKey, std::vector<std::vector<unsigned
             vSolutionsRet.push_back(witnessprogram);
             return TX_WITNESS_V0_SCRIPTHASH;
         }
+        if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE) {
+            vSolutionsRet.push_back(witnessprogram);
+            return TX_WITNESS_V1_TAPROOT;
+        }
         if (witnessversion != 0) {
             vSolutionsRet.push_back(std::vector<unsigned char>{(unsigned char)witnessversion});
             vSolutionsRet.push_back(std::move(witnessprogram));
@@ -185,6 +190,10 @@ bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet)
         std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
         addressRet = hash;
         return true;
+    } else if (whichType == TX_WITNESS_V1_TAPROOT) {
+        vSolutions[0][0] += 2;
+        addressRet = WitnessV1Point(vSolutions[0]);
+        return true;
     } else if (whichType == TX_WITNESS_UNKNOWN) {
         WitnessUnknown unk;
         unk.version = vSolutions[0][0];
@@ -270,6 +279,15 @@ class CScriptVisitor : public boost::static_visitor<bool>
         return true;
     }
 
+    bool operator()(const WitnessV1Point& id) const
+    {
+        script->clear();
+        std::vector<unsigned char> point = ToByteVector(id);
+        point[0] -= 2; // According to BIP-Taproot;
+        *script << OP_1 << point;
+        return true;
+    }
+
     bool operator()(const WitnessV0ScriptHash& id) const
     {
         script->clear();
diff --git a/src/script/standard.h b/src/script/standard.h
index e45e2d92cc15c..201d6bb8e6a8b 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -11,6 +11,7 @@
 
 #include <boost/variant.hpp>
 
+#include <pubkey.h>
 #include <stdint.h>
 
 static const bool DEFAULT_ACCEPT_DATACARRIER = true;
@@ -64,6 +65,7 @@ enum txnouttype
     TX_NULL_DATA, //!< unspendable OP_RETURN script that carries data
     TX_WITNESS_V0_SCRIPTHASH,
     TX_WITNESS_V0_KEYHASH,
+    TX_WITNESS_V1_TAPROOT,
     TX_WITNESS_UNKNOWN, //!< Only for Witness versions not already defined above
 };
 
@@ -97,6 +99,13 @@ struct WitnessV0ScriptHash : public uint256
     using uint256::uint256;
 };
 
+struct WitnessV1Point : public CPubKey
+{
+    WitnessV1Point() : CPubKey() {}
+    explicit WitnessV1Point(const CPubKey& key) : CPubKey(key) {}
+    using CPubKey::CPubKey;
+};
+
 struct WitnessV0KeyHash : public uint160
 {
     WitnessV0KeyHash() : uint160() {}
@@ -134,9 +143,10 @@ struct WitnessUnknown
  *  * WitnessV0ScriptHash: TX_WITNESS_V0_SCRIPTHASH destination (P2WSH)
  *  * WitnessV0KeyHash: TX_WITNESS_V0_KEYHASH destination (P2WPKH)
  *  * WitnessUnknown: TX_WITNESS_UNKNOWN destination (P2W???)
+ *  * WitnessV1Point: Taproot destination
  *  A CTxDestination is the internal data type encoded in a bitcoin address
  */
-typedef boost::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessUnknown> CTxDestination;
+typedef boost::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Point, WitnessUnknown> CTxDestination;
 
 /** Check whether a CTxDestination is a CNoDestination. */
 bool IsValidDestination(const CTxDestination& dest);
diff --git a/src/test/descriptor_tests.cpp b/src/test/descriptor_tests.cpp
index 1b9ec7638505d..b46966dfc5d2a 100644
--- a/src/test/descriptor_tests.cpp
+++ b/src/test/descriptor_tests.cpp
@@ -173,6 +173,20 @@ BOOST_FIXTURE_TEST_SUITE(descriptor_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(descriptor_test)
 {
+
+    Check("tap(KwXyp3nhG2ezACSj4fj1fSPVXeArbcGhbj7QSJ3Ka9tkQrE18gPH,pkh(L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1))",
+          "tap(031e34802508ce0bbabb71935832c92129c6df82143a924d731c43362495111319,pkh(03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd))",
+          DEFAULT, {{"512100457f38eaa540b3974589d892706fddeb76b53b3bb047593dcbd2b6cca779db46"}});
+    Check("tap(KwXyp3nhG2ezACSj4fj1fSPVXeArbcGhbj7QSJ3Ka9tkQrE18gPH)",
+          "tap(031e34802508ce0bbabb71935832c92129c6df82143a924d731c43362495111319)",
+          DEFAULT, {{"5121011e34802508ce0bbabb71935832c92129c6df82143a924d731c43362495111319"}});
+    Check("tap([deadbeef/1/2'/3/4']KwXyp3nhG2ezACSj4fj1fSPVXeArbcGhbj7QSJ3Ka9tkQrE18gPH,{pk([deadbeef/1/2'/3/4']KwWtyFT2oVBmAgzSE6hvpYjcZQkAeX4i4bxtfHVKzGGLSLLW2BLb),pkh([deadbeef/1/2'/3/4']L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1)})",
+          "tap([deadbeef/1/2'/3/4']031e34802508ce0bbabb71935832c92129c6df82143a924d731c43362495111319,{pk([deadbeef/1/2'/3/4']0257dd0c7c2e9036b845ff4f8a90eeed5daf821e7abd1f98dcbc8b65b0006d28ce),pkh([deadbeef/1/2'/3/4']03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)})",
+          DEFAULT, {{"512101c7788f3db33c5282bf424aa3dd4e0e46f39cde13cb0ce7740e6a5a0f2f89696f"}}, {{1,0x80000002UL,3,0x80000004UL}});
+    Check("tap(KwXyp3nhG2ezACSj4fj1fSPVXeArbcGhbj7QSJ3Ka9tkQrE18gPH,{pk(KwWtyFT2oVBmAgzSE6hvpYjcZQkAeX4i4bxtfHVKzGGLSLLW2BLb),pkh([deadbeef/1/2'/3/4']L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1)})",
+          "tap(031e34802508ce0bbabb71935832c92129c6df82143a924d731c43362495111319,{pk(0257dd0c7c2e9036b845ff4f8a90eeed5daf821e7abd1f98dcbc8b65b0006d28ce),pkh([deadbeef/1/2'/3/4']03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)})",
+          DEFAULT, {{"512101c7788f3db33c5282bf424aa3dd4e0e46f39cde13cb0ce7740e6a5a0f2f89696f"}}, {{1,0x80000002UL,3,0x80000004UL}, {}}); // only some have paths Key Derivation.
+
     // Basic single-key compressed
     Check("combo(L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1)", "combo(03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)", SIGNABLE, {{"2103a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bdac","76a9149a1c78a507689f6f54b847ad1cef1e614ee23f1e88ac","00149a1c78a507689f6f54b847ad1cef1e614ee23f1e","a91484ab21b1b2fd065d4504ff693d832434b6108d7b87"}});
     Check("pk(L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1)", "pk(03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd)", SIGNABLE, {{"2103a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bdac"}});
@@ -190,6 +204,10 @@ BOOST_AUTO_TEST_CASE(descriptor_test)
     CheckUnparsable("wpkh(5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss)", "wpkh(04a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea235)", "Uncompressed keys are not allowed"); // No uncompressed keys in witness
     CheckUnparsable("wsh(pk(5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss))", "wsh(pk(04a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea235))", "Uncompressed keys are not allowed"); // No uncompressed keys in witness
     CheckUnparsable("sh(wpkh(5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss))", "sh(wpkh(04a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea235))", "Uncompressed keys are not allowed"); // No uncompressed keys in witness
+    CheckUnparsable("tap(5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss)", "tap(04a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea235)", "Uncompressed keys are not allowed"); // No uncompressed keys in witness
+    CheckUnparsable("tap(KwXyp3nhG2ezACSj4fj1fSPVXeArbcGhbj7QSJ3Ka9tkQrE18gPH,{pk(L47CwsA9469CtukSyzC3QM3X4Gdqa5VE116C8WYzdx4BwW13bXZ8),pkh(5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss)})",
+        "tap(031e34802508ce0bbabb71935832c92129c6df82143a924d731c43362495111319,{pk(023e93f827793706dffdca946b64842f69c336c8dd78f32d716ee7e77dfe119418),pkh(04a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea235)})", "Uncompressed keys are not allowed"); // No uncompressed keys in witness
+    CheckUnparsable("tap(KwXyp3nhG2ezACSj4fj1fSPVXeArbcGhbj7QSJ3Ka9tkQrE18gPH,{pk(KwWtyFT2oVBmAgzSE6hvpYjcZQkAeX4i4bxtfHVKzGGLSLLW2BLb)})", "tap(031e34802508ce0bbabb71935832c92129c6df82143a924d731c43362495111319,{pk(0257dd0c7c2e9036b845ff4f8a90eeed5daf821e7abd1f98dcbc8b65b0006d28ce)})", "Missing leafs"); // Only one leaf
 
     // Some unconventional single-key constructions
     Check("sh(pk(L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1))", "sh(pk(03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd))", SIGNABLE, {{"a9141857af51a5e516552b3086430fd8ce55f7c1a52487"}});
@@ -206,9 +224,18 @@ BOOST_AUTO_TEST_CASE(descriptor_test)
     Check("wpkh([ffffffff/13']xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt/1/2/*)", "wpkh([ffffffff/13']xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH/1/2/*)", RANGE, {{"0014326b2249e3a25d5dc60935f044ee835d090ba859"},{"0014af0bd98abc2f2cae66e36896a39ffe2d32984fb7"},{"00141fa798efd1cbf95cebf912c031b8a4a6e9fb9f27"}}, {{0x8000000DUL, 1, 2, 0}, {0x8000000DUL, 1, 2, 1}, {0x8000000DUL, 1, 2, 2}});
     Check("sh(wpkh(xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi/10/20/30/40/*'))", "sh(wpkh(xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8/10/20/30/40/*'))", RANGE | HARDENED, {{"a9149a4d9901d6af519b2a23d4a2f51650fcba87ce7b87"},{"a914bed59fc0024fae941d6e20a3b44a109ae740129287"},{"a9148483aa1116eb9c05c482a72bada4b1db24af654387"}}, {{10, 20, 30, 40, 0x80000000UL}, {10, 20, 30, 40, 0x80000001UL}, {10, 20, 30, 40, 0x80000002UL}});
     Check("combo(xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334/*)", "combo(xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV/*)", RANGE, {{"2102df12b7035bdac8e3bab862a3a83d06ea6b17b6753d52edecba9be46f5d09e076ac","76a914f90e3178ca25f2c808dc76624032d352fdbdfaf288ac","0014f90e3178ca25f2c808dc76624032d352fdbdfaf2","a91408f3ea8c68d4a7585bf9e8bda226723f70e445f087"},{"21032869a233c9adff9a994e4966e5b821fd5bac066da6c3112488dc52383b4a98ecac","76a914a8409d1b6dfb1ed2a3e8aa5e0ef2ff26b15b75b788ac","0014a8409d1b6dfb1ed2a3e8aa5e0ef2ff26b15b75b7","a91473e39884cb71ae4e5ac9739e9225026c99763e6687"}}, {{0}, {1}});
+
+    Check("tap(xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi/10/20/30/40/*')", "tap(xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8/10/20/30/40/*')", RANGE | HARDENED, {{"5121010a222cbb7187367ea5145c98ff029937fd897292aaa9e52f975c4a71a34d8671"},{"5121008c22dde9f1cd0157a43ba9254cab16e50ecb00f3a124a72c990e6b13280bd3a9"},{"512101823c2dee4a74788ed2dc59e45ac183c444f625f269a83c692b2af2bd6440c286"}}, {{10, 20, 30, 40, 0x80000000UL}, {10, 20, 30, 40, 0x80000001UL}, {10, 20, 30, 40, 0x80000002UL}});
+    Check("tap(xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi/10/20/30/40/*',{pk([ffffffff/13']xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt/1/2/*),pkh([ffffffff/13']xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt/1/2/*)})", "tap(xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8/10/20/30/40/*',{pk([ffffffff/13']xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH/1/2/*),pkh([ffffffff/13']xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH/1/2/*)})", RANGE | HARDENED, {{"512100c4d3190ea7c73045d01e870cec69f7a8fb6d7d1825288e4ff5cdcafb617b30e0"},{"512101b81e745fef14874c47d2918bff7fb24dafbddfc9d3ca01de1b88c6720aeada56"},{"51210068cf95250bef0738cb106513294129a6ebb109f41eb384ff98fa9b18d8e139c6"}}, {{10, 20, 30, 40, 0x80000000UL}, {10, 20, 30, 40, 0x80000001UL}, {10, 20, 30, 40, 0x80000002UL}, {0x8000000DUL, 1, 2, 0}});
+    Check("tap(xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U/2147483647'/0)", "tap(xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB/2147483647'/0)", HARDENED, {{"512100d09efc9b0092ddd4daddd8b65805834232c397c22064d620c1324ceda113c924"}}, {{0xFFFFFFFFUL,0}});
+
     CheckUnparsable("combo([012345678]xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc)", "combo([012345678]xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL)", "Fingerprint is not 4 bytes (9 characters instead of 8 characters)"); // Too long key fingerprint
     CheckUnparsable("pkh(xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U/2147483648)", "pkh(xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB/2147483648)", "Key path value 2147483648 is out of range"); // BIP 32 path element overflow
     CheckUnparsable("pkh(xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U/1aa)", "pkh(xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB/1aa)", "Key path value '1aa' is not a valid uint32"); // Path is not valid uint
+    CheckUnparsable("tap([012345678]xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc)", "tap([012345678]xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL)", "Fingerprint is not 4 bytes (9 characters instead of 8 characters)"); // Too long key fingerprint
+    CheckUnparsable("tap(KwXyp3nhG2ezACSj4fj1fSPVXeArbcGhbj7QSJ3Ka9tkQrE18gPH,{pk(KwWtyFT2oVBmAgzSE6hvpYjcZQkAeX4i4bxtfHVKzGGLSLLW2BLb),pkh(xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U/2147483648)})",
+        "tap(031e34802508ce0bbabb71935832c92129c6df82143a924d731c43362495111319,{pk(0257dd0c7c2e9036b845ff4f8a90eeed5daf821e7abd1f98dcbc8b65b0006d28ce),pkh(xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB/2147483648)})", "Key path value 2147483648 is out of range"); // BIP 32 path element overflow
+
 
     // Multisig constructions
     Check("multi(1,L4rK1yDtCWekvXuE6oXD9jCYfFNV2cWRpVuPLBcCU2z8TrisoyY1,5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss)", "multi(1,03a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd,04a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea235)", SIGNABLE, {{"512103a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd4104a34b99f22c790c4e36b2b3c2c35a36db06226e41c692fc82b8b56ac1c540c5bd5b8dec5235a0fa8722476c7709c02559e3aa73aa03918ba2d492eea75abea23552ae"}});
diff --git a/src/test/script_standard_tests.cpp b/src/test/script_standard_tests.cpp
index 412a57dd9db39..8eb4733414e98 100644
--- a/src/test/script_standard_tests.cpp
+++ b/src/test/script_standard_tests.cpp
@@ -221,13 +221,22 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
     BOOST_CHECK(ExtractDestination(s, address));
     BOOST_CHECK(boost::get<WitnessV0ScriptHash>(&address) && *boost::get<WitnessV0ScriptHash>(&address) == scripthash);
 
+    // TX_WITNESS_V1_SCRIPTHASH
+    s.clear();
+    WitnessV1Point taproot(pubkey);
+    auto modified_key = ToByteVector(pubkey);
+    modified_key[0] -= 2;
+    s << OP_1 << modified_key;
+    BOOST_CHECK(ExtractDestination(s, address));
+    BOOST_CHECK(boost::get<WitnessV1Point>(&address) && *boost::get<WitnessV1Point>(&address) == taproot);
+
     // TX_WITNESS with unknown version
     s.clear();
-    s << OP_1 << ToByteVector(pubkey);
+    s << OP_2 << ToByteVector(pubkey);
     BOOST_CHECK(ExtractDestination(s, address));
     WitnessUnknown unk;
     unk.length = 33;
-    unk.version = 1;
+    unk.version = 2;
     std::copy(pubkey.begin(), pubkey.end(), unk.program);
     BOOST_CHECK(boost::get<WitnessUnknown>(&address) && *boost::get<WitnessUnknown>(&address) == unk);
 }
diff --git a/src/wallet/ismine.cpp b/src/wallet/ismine.cpp
index b7ef2d44904ac..84e3b27a8f7ee 100644
--- a/src/wallet/ismine.cpp
+++ b/src/wallet/ismine.cpp
@@ -68,6 +68,7 @@ IsMineResult IsMineInner(const CWallet& keystore, const CScript& scriptPubKey, I
     case TX_NONSTANDARD:
     case TX_NULL_DATA:
     case TX_WITNESS_UNKNOWN:
+    case TX_WITNESS_V1_TAPROOT:
         break;
     case TX_PUBKEY:
         keyID = CPubKey(vSolutions[0]).GetID();
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 30e767e48992e..5ff81941557d7 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -3616,6 +3616,17 @@ class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue>
         return obj;
     }
 
+    UniValue operator()(const WitnessV1Point& id) const
+    {
+        UniValue obj(UniValue::VOBJ);
+        CPubKey pubkey;
+        // TODO: Add tweak and script paths?
+        if (pwallet && pwallet->GetPubKey(CKeyID(id.GetID()), pubkey)) {
+            obj.pushKV("taproot internal-key", HexStr(pubkey));
+        }
+        return obj;
+    }
+
     UniValue operator()(const WitnessUnknown& id) const { return UniValue(UniValue::VOBJ); }
 };