diff --git a/NBitcoin/Scripting/AddressDescriptor.cs b/NBitcoin/Scripting/AddressDescriptor.cs
new file mode 100644
index 0000000000..4449c74115
--- /dev/null
+++ b/NBitcoin/Scripting/AddressDescriptor.cs
@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+
+namespace NBitcoin.Scripting
+{
+    /** A parsed addr(A) descriptor. */
+    public class AddressDescriptor : DescriptorImpl
+	{
+		private IDestination m_destination;
+
+		protected string ToStringExtra()  { return EncodeDestination(m_destination); }
+		protected List<Script> MakeScripts(List<PubKey> pubkeys, Script script, FlatSigningProvider signingProvider)  { return Vector(GetScriptForDestination(m_destination)); }
+	
+		public AddressDescriptor(IDestination destination)
+			: base(null, null, "addr")
+		{
+			m_destination = destination;
+		}
+		public bool IsSolvable(){ return false; }
+
+		public Optional<OutputType> GetOutputType() 
+		{
+			switch (m_destination.which()) {
+				case 1 /* PKHash */:
+				case 2 /* ScriptHash */: return OutputType::LEGACY;
+				case 3 /* WitnessV0ScriptHash */:
+				case 4 /* WitnessV0KeyHash */:
+				case 5 /* WitnessUnknown */: return OutputType::BECH32;
+				case 0 /* CNoDestination */:
+				default: return nullopt;
+			}
+		}
+		public bool IsSingleType(){ return true; }
+	}
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/BIP32PubkeyProvider.cs b/NBitcoin/Scripting/BIP32PubkeyProvider.cs
new file mode 100644
index 0000000000..3ec5235dd2
--- /dev/null
+++ b/NBitcoin/Scripting/BIP32PubkeyProvider.cs
@@ -0,0 +1,149 @@
+namespace NBitcoin.Scripting
+{
+	/** An object representing a parsed extended public key in a descriptor. */
+	public class BIP32PubkeyProvider : PubkeyProvider
+	{
+		// Root xpub, path, and final derivation step type being used, if any
+		private ExtPubKey m_root_extkey;
+		private KeyPath m_path;
+		private DeriveType m_derive;
+		// Cache of the parent of the final derived pubkeys.
+		// Primarily useful for situations when no read_cache is provided
+		private ExtPubKey m_cached_xpub;
+
+		private bool GetExtKey(SigningProvider arg, ExtKey ret)
+		{
+			Key key;
+			if (!arg.GetKey(m_root_extkey.pubkey.GetID(), key)) return false;
+			ret.nDepth = m_root_extkey.nDepth;
+			std::copy(m_root_extkey.vchFingerprint, m_root_extkey.vchFingerprint + sizeof(ret.vchFingerprint), ret.vchFingerprint);
+			ret.nChild = m_root_extkey.nChild;
+			ret.chaincode = m_root_extkey.chaincode;
+			ret.key = key;
+			return true;
+		}
+
+		// Derives the last xprv
+		private bool GetDerivedExtKey(SigningProvider arg, ExtKey xprv)
+		{
+			if (!GetExtKey(arg, xprv)) return false;
+			foreach (var entry  in  m_path) {
+				xprv.Derive(xprv, entry);
+			}
+			return true;
+		}
+
+		private bool IsHardened()
+		{
+			if (m_derive == DeriveType::HARDENED) return true;
+			foreach (var entry  in  m_path) {
+				if (entry >> 31) return true;
+			}
+			return false;
+		}
+
+		public BIP32PubkeyProvider(uint exp_index, ExtPubKey extkey, KeyPath path, DeriveType derive) 
+			: base(exp_index)
+		{
+			m_root_extkey = extkey;
+			m_path = path;
+			m_derive = derive;
+		} 
+		public bool IsRange()  { return m_derive != DeriveType::NO; }
+		public uint GetSize()  { return 33; }
+		public bool GetPubKey(int pos, SigningProvider arg, PubKey key_out, KeyOriginInfo final_info_out, DescriptorCache read_cache = null, DescriptorCache write_cache = null) 
+		{
+			// Info of parent of the to be derived pubkey
+			KeyOriginInfo parent_info;
+			KeyID keyid = m_root_extkey.pubkey.GetID();
+			std::copy(keyid.begin(), keyid.begin() + sizeof(parent_info.fingerprint), parent_info.fingerprint);
+			parent_info.path = m_path;
+
+			// Info of the derived key itself which is copied out upon successful completion
+			KeyOriginInfo final_info_out_tmp = parent_info;
+			if (m_derive == DeriveType::UNHARDENED) final_info_out_tmp.path.push_back((uint32_t)pos);
+			if (m_derive == DeriveType::HARDENED) final_info_out_tmp.path.push_back(((uint32_t)pos) | 0x80000000L);
+
+			// Derive keys or fetch them from cache
+			ExtPubKey final_extkey = m_root_extkey;
+			ExtPubKey parent_extkey = m_root_extkey;
+			bool der = true;
+			if (read_cache) {
+				if (!read_cache.GetCachedDerivedExtPubKey(m_expr_index, pos, final_extkey)) {
+					if (m_derive == DeriveType::HARDENED) return false;
+					// Try to get the derivation parent
+					if (!read_cache.GetCachedParentExtPubKey(m_expr_index, parent_extkey)) return false;
+					final_extkey = parent_extkey;
+					if (m_derive == DeriveType::UNHARDENED) der = parent_extkey.Derive(final_extkey, pos);
+				}
+			} else if (m_cached_xpub.pubkey.IsValid() && m_derive != DeriveType::HARDENED) {
+				parent_extkey = final_extkey = m_cached_xpub;
+				if (m_derive == DeriveType::UNHARDENED) der = parent_extkey.Derive(final_extkey, pos);
+			} else if (IsHardened()) {
+				ExtKey xprv;
+				if (!GetDerivedExtKey(arg, xprv)) return false;
+				parent_extkey = xprv.Neuter();
+				if (m_derive == DeriveType::UNHARDENED) der = xprv.Derive(xprv, pos);
+				if (m_derive == DeriveType::HARDENED) der = xprv.Derive(xprv, pos | 0x80000000UL);
+				final_extkey = xprv.Neuter();
+			} else {
+				foreach (var entry  in  m_path) {
+					der = parent_extkey.Derive(parent_extkey, entry);
+					assert(der);
+				}
+				final_extkey = parent_extkey;
+				if (m_derive == DeriveType::UNHARDENED) der = parent_extkey.Derive(final_extkey, pos);
+				assert(m_derive != DeriveType::HARDENED);
+			}
+			assert(der);
+
+			final_info_out = final_info_out_tmp;
+			key_out = final_extkey.pubkey;
+
+			// We rely on the consumer to check that m_derive isn't HARDENED as above
+			// But we can't have already cached something in case we read something from the cache
+			// and parent_extkey isn't actually the parent.
+			if (!m_cached_xpub.pubkey.IsValid()) m_cached_xpub = parent_extkey;
+
+			if (write_cache) {
+				// Only cache parent if there is any unhardened derivation
+				if (m_derive != DeriveType::HARDENED) {
+					write_cache.CacheParentExtPubKey(m_expr_index, parent_extkey);
+				} else if (final_info_out.path.size() > 0) {
+					write_cache.CacheDerivedExtPubKey(m_expr_index, pos, final_extkey);
+				}
+			}
+
+			return true;
+		}
+		public override string ToString() 
+		{
+			string ret = EncodeExtPubKey(m_root_extkey) + FormatHDKeypath(m_path);
+			if (IsRange()) {
+				ret += "/*";
+				if (m_derive == DeriveType::HARDENED) ret += '\'';
+			}
+			return ret;
+		}
+		public bool ToPrivateString(SigningProvider arg, out string output) 
+		{
+			ExtKey key;
+			if (!GetExtKey(arg, key)) return false;
+			output = EncodeExtKey(key) + FormatHDKeypath(m_path);
+			if (IsRange()) {
+				output += "/*";
+				if (m_derive == DeriveType::HARDENED) output += '\'';
+			}
+			return true;
+		}
+		public bool GetPrivKey(int pos, SigningProvider arg, out Key key) 
+		{
+			ExtKey extkey;
+			if (!GetDerivedExtKey(arg, extkey)) return false;
+			if (m_derive == DeriveType::UNHARDENED) extkey.Derive(extkey, pos);
+			if (m_derive == DeriveType::HARDENED) extkey.Derive(extkey, pos | 0x80000000UL);
+			key = extkey.key;
+			return true;
+		}
+	}
+}
\ No newline at end of file
diff --git a/NBitcoin/Scripting/ComboDescriptor.cs b/NBitcoin/Scripting/ComboDescriptor.cs
new file mode 100644
index 0000000000..d452acb0b5
--- /dev/null
+++ b/NBitcoin/Scripting/ComboDescriptor.cs
@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+
+namespace NBitcoin.Scripting
+{
+    /** A parsed combo(P) descriptor. */
+    class ComboDescriptor :DescriptorImpl
+	{
+		protected List<Script> MakeScripts(List<PubKey> keys, Script script, out FlatSigningProvider output) 
+		{
+			List<Script> ret;
+			KeyID id = keys[0].GetID();
+			output.pubkeys.emplace(id, keys[0]);
+			ret.emplace_back(GetScriptForRawPubKey(keys[0])); // P2PK
+			ret.emplace_back(GetScriptForDestination(PKHash(id))); // P2PKH
+			if (keys[0].IsCompressed()) {
+				Script p2wpkh = GetScriptForDestination(WitnessV0KeyHash(id));
+				output.scripts.emplace(ScriptID(p2wpkh), p2wpkh);
+				ret.emplace_back(p2wpkh);
+				ret.emplace_back(GetScriptForDestination(ScriptHash(p2wpkh))); // P2SH-P2WPKH
+			}
+			return ret;
+		}
+	
+		public ComboDescriptor(std::unique_ptr<PubkeyProvider> prov) : base(Vector(prov), null, "combo") {}
+		public bool IsSingleType(){ return false; }
+	}
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/ConstPubkeyProvider.cs b/NBitcoin/Scripting/ConstPubkeyProvider.cs
new file mode 100644
index 0000000000..afb471de7b
--- /dev/null
+++ b/NBitcoin/Scripting/ConstPubkeyProvider.cs
@@ -0,0 +1,37 @@
+namespace NBitcoin.Scripting
+{
+    /** An object representing a parsed constant public key in a descriptor. */
+    public class ConstPubkeyProvider : PubkeyProvider
+	{
+		private PubKey m_pubkey;
+
+		public ConstPubkeyProvider(uint exp_index, PubKey pubkey) 
+			: base(exp_index)
+		{ 
+			m_pubkey = pubkey;
+		}
+
+		public bool GetPubKey(int pos, SigningProvider arg, PubKey key, KeyOriginInfo info, DescriptorCache read_cache = null, DescriptorCache write_cache = null) 
+		{
+			key = m_pubkey;
+			info.path.clear();
+			KeyID keyid = m_pubkey.GetID();
+			std::copy(keyid.begin(), keyid.begin() + sizeof(info.fingerprint), info.fingerprint);
+			return true;
+		}
+		public bool IsRange()  { return false; }
+		public uint GetSize()  { return m_pubkey.size(); }
+		public string ToString()  { return HexStr(m_pubkey); }
+		public bool ToPrivateString(SigningProvider arg, string ret) 
+		{
+			Key key;
+			if (!arg.GetKey(m_pubkey.GetID(), key)) return false;
+			ret = EncodeSecret(key);
+			return true;
+		}
+		public bool GetPrivKey(int pos, SigningProvider arg, Key key) 
+		{
+			return arg.GetKey(m_pubkey.GetID(), key);
+		}
+	};
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/DescriptorCache.cs b/NBitcoin/Scripting/DescriptorCache.cs
new file mode 100644
index 0000000000..1318fb0699
--- /dev/null
+++ b/NBitcoin/Scripting/DescriptorCache.cs
@@ -0,0 +1,76 @@
+using System.Collections.Generic;
+
+namespace NBitcoin.Scripting
+{
+    /** Cache for single descriptor's derived extended pubkeys */
+    public class DescriptorCache
+	{
+		/** Map key expression index . map of (key derivation index . xpub) */
+		private IDictionary<uint, ExtPubKeyMap> m_derived_xpubs;
+		/** Map key expression index . parent xpub */
+		private ExtPubKeyMap m_parent_xpubs;
+
+		/** Cache a parent xpub
+		*
+		* @param[in] key_exp_pos Position of the key expression within the descriptor
+		* @param[in] xpub The ExtPubKey to cache
+		*/
+		public void CacheParentExtPubKey(uint key_exp_pos, ExtPubKey xpub)
+		{
+			m_parent_xpubs[key_exp_pos] = xpub;
+		}
+
+		/** Retrieve a cached parent xpub
+		*
+		* @param[in] key_exp_pos Position of the key expression within the descriptor
+		* @param[in] xpub The ExtPubKey to get from cache
+		*/
+		public bool GetCachedParentExtPubKey(uint key_exp_pos, ExtPubKey xpub)
+		{
+			var it = m_parent_xpubs.find(key_exp_pos);
+			if (it == m_parent_xpubs.end()) return false;
+			xpub = it.second;
+			return true;
+		}
+
+		/** Cache an xpub derived at an index
+		*
+		* @param[in] key_exp_pos Position of the key expression within the descriptor
+		* @param[in] der_index Derivation index of the xpub
+		* @param[in] xpub The ExtPubKey to cache
+		*/
+		public void CacheDerivedExtPubKey(uint key_exp_pos, uint der_index, ExtPubKey xpub)
+		{
+			var xpubs = m_derived_xpubs[key_exp_pos];
+			xpubs[der_index] = xpub;
+		}
+
+		/** Retrieve a cached xpub derived at an index
+		*
+		* @param[in] key_exp_pos Position of the key expression within the descriptor
+		* @param[in] der_index Derivation index of the xpub
+		* @param[in] xpub The ExtPubKey to get from cache
+		*/
+		public bool GetCachedDerivedExtPubKey(uint key_exp_pos, uint der_index, ExtPubKey xpub)
+		{
+			var key_exp_it = m_derived_xpubs.find(key_exp_pos);
+			if (key_exp_it == m_derived_xpubs.end()) return false;
+			var der_it = key_exp_it.second.find(der_index);
+			if (der_it == key_exp_it.second.end()) return false;
+			xpub = der_it.second;
+			return true;
+		}
+
+		/** Retrieve all cached parent xpubs */
+		public ExtPubKeyMap GetCachedParentExtPubKeys()
+		{
+			return m_parent_xpubs;
+		}
+
+		/** Retrieve all cached derived xpubs */
+		public IDictionary<uint32_t, ExtPubKeyMap> GetCachedDerivedExtPubKeys()
+		{
+			return m_derived_xpubs;
+		}
+	};
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/DescriptorImpl.cs b/NBitcoin/Scripting/DescriptorImpl.cs
new file mode 100644
index 0000000000..6209c94e67
--- /dev/null
+++ b/NBitcoin/Scripting/DescriptorImpl.cs
@@ -0,0 +1,162 @@
+using System.Collections.Generic;
+
+namespace NBitcoin.Scripting
+{
+    /** Base class for all Descriptor implementations. */
+    public class DescriptorImpl : Descriptor
+	{
+		//! Public key arguments for this descriptor (size 1 for PK, PKH, WPKH; any size for Multisig).
+		private List<std::unique_ptr<PubkeyProvider>> m_pubkey_args;
+		//! The string name of the descriptor function.
+		private string m_name;
+
+		//! The sub-descriptor argument (null for everything but SH and WSH).
+		//! In doc/descriptors.m this is referred to as SCRIPT expressions sh(SCRIPT)
+		//! and wsh(SCRIPT), and distinct from KEY expressions and ADDR expressions.
+		protected std::unique_ptr<DescriptorImpl> m_subdescriptor_arg;
+
+		//! Return a serialization of anything except pubkey and script arguments, to be prepended to those.
+		protected virtual string ToStringExtra() { return ""; }
+
+		/** A helper function to construct the scripts for this descriptor.
+		*
+		*  This function is invoked once for every Script produced by evaluating
+		*  m_subdescriptor_arg, or just once in case m_subdescriptor_arg is null.
+
+		*  @param pubkeys The evaluations of the m_pubkey_args field.
+		*  @param script The evaluation of m_subdescriptor_arg (or null when m_subdescriptor_arg is null).
+		*  @param out A FlatSigningProvider to put scripts or public keys in that are necessary to the solver.
+		*             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.
+		*/
+		protected virtual List<Script> MakeScripts(List<PubKey> pubkeys, Script* script, FlatSigningProvider output);
+
+		public DescriptorImpl(List<std::unique_ptr<PubkeyProvider>> pubkeys, std::unique_ptr<DescriptorImpl> script, string name) 
+		{
+			m_pubkey_args = pubkeys; 
+			m_name = name; 
+			m_subdescriptor_arg = script;
+		}
+
+		public bool IsSolvable() 
+		{
+			if (m_subdescriptor_arg) {
+				if (!m_subdescriptor_arg.IsSolvable()) return false;
+			}
+			return true;
+		}
+
+		public bool IsRange()
+		{
+			foreach (var pubkey in m_pubkey_args) {
+				if (pubkey.IsRange()) return true;
+			}
+			if (m_subdescriptor_arg) {
+				if (m_subdescriptor_arg.IsRange()) return true;
+			}
+			return false;
+		}
+
+		public bool ToStringHelper(SigningProvider* arg, out string output, bool priv)
+		{
+			string extra = ToStringExtra();
+			uint pos = extra.size() > 0 ? 1 : 0;
+			string ret = m_name + "(" + extra;
+			foreach (var pubkey in m_pubkey_args) {
+				if (pos++) ret += ",";
+				string tmp;
+				if (priv) {
+					if (!pubkey.ToPrivateString(*arg, tmp)) return false;
+				} else {
+					tmp = pubkey.ToString();
+				}
+				ret += tmp;
+			}
+			if (m_subdescriptor_arg) {
+				if (pos++) ret += ",";
+				string tmp;
+				if (!m_subdescriptor_arg.ToStringHelper(arg, tmp, priv)) return false;
+				ret += tmp;
+			}
+			output = ret + ")";
+			return true;
+		}
+
+		public override string ToString()
+		{
+			string ret;
+			ToStringHelper(null, ret, false);
+			return AddChecksum(ret);
+		}
+
+		public bool ToPrivateString(SigningProvider arg, out string outputput)
+		{
+			bool ret = ToStringHelper(arg, out, true);
+			outpur = AddChecksum(out);
+			return ret;
+		}
+
+		public bool ExpandHelper(int pos, SigningProvider arg, DescriptorCache read_cache, List<Script> output_scripts, out FlatSigningProvider output, DescriptorCache write_cache)
+		{
+			List<std::pair<PubKey, KeyOriginInfo>> entries;
+			entries.reserve(m_pubkey_args.size());
+
+			// Construct temporary data in `entries` and `subscripts`, to avoid producing output in case of failure.
+			for (auto p : m_pubkey_args) {
+				entries.emplace_back();
+				if (!p.GetPubKey(pos, arg, entries.back().first, entries.back().second, read_cache, write_cache)) return false;
+			}
+			List<Script> subscripts;
+			if (m_subdescriptor_arg) {
+				FlatSigningProvider subprovider;
+				if (!m_subdescriptor_arg.ExpandHelper(pos, arg, read_cache, subscripts, subprovider, write_cache)) return false;
+				out = Merge(out, subprovider);
+			}
+
+			List<PubKey> pubkeys;
+			pubkeys.reserve(entries.size());
+			for (auto entry : entries) {
+				pubkeys.push_back(entry.first);
+				out.origins.emplace(entry.first.GetID(), std::make_pair<PubKey, KeyOriginInfo>(PubKey(entry.first), entry.second));
+			}
+			if (m_subdescriptor_arg) {
+				for (auto subscript : subscripts) {
+					out.scripts.emplace(ScriptID(subscript), subscript);
+					List<Script> addscripts = MakeScripts(pubkeys, subscript, output);
+					for (auto addscript : addscripts) {
+						output_scripts.push_back(addscript);
+					}
+				}
+			} else {
+				output_scripts = MakeScripts(pubkeys, null, output);
+			}
+			return true;
+		}
+
+		public bool Expand(int pos, SigningProvider provider, List<Script> output_scripts, FlatSigningProvider out, DescriptorCache write_cache = null)
+		{
+			return ExpandHelper(pos, provider, null, output_scripts, out, write_cache);
+		}
+
+		public bool ExpandFromCache(int pos, DescriptorCache read_cache, List<Script> output_scripts, FlatSigningProvider output)
+		{
+			return ExpandHelper(pos, DUMMY_SIGNING_PROVIDER, read_cache, output_scripts, out, null);
+		}
+
+		public void ExpandPrivate(int pos, SigningProvider provider, FlatSigningProvider output)
+		{
+			for (auto p : m_pubkey_args) {
+				Key key;
+				if (!p.GetPrivKey(pos, provider, key)) continue;
+				out.keys.emplace(key.GetPubKey().GetID(), key);
+			}
+			if (m_subdescriptor_arg) {
+				FlatSigningProvider subprovider;
+				m_subdescriptor_arg.ExpandPrivate(pos, provider, subprovider);
+				out = Merge(out, subprovider);
+			}
+		}
+
+		Optional<OutputType> GetOutputType()  { return nullopt; }
+	}
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/IDescriptor.cs b/NBitcoin/Scripting/IDescriptor.cs
new file mode 100644
index 0000000000..52978598d1
--- /dev/null
+++ b/NBitcoin/Scripting/IDescriptor.cs
@@ -0,0 +1,65 @@
+namespace NBitcoin.Scripting
+{
+    // Interface for parsed descriptor objects.
+    //
+    // Descriptors are strings that describe a set of scriptPubKeys, together with
+    // all information necessary to solve them. By combining all information into
+    // one, they avoid the need to separately import keys and scripts.
+    //
+    // Descriptors may be ranged, which occurs when the public keys inside are
+    // specified in the form of HD chains (xpubs).
+    //
+    // Descriptors always represent public information - public keys and scripts -
+    // but in cases where private keys need to be conveyed along with a descriptor,
+    // they can be included inside by changing public keys to private keys (WIF
+    // format), and changing xpubs by xprvs.
+    //
+    // Reference documentation about the descriptor language can be found in
+    // doc/descriptors.md.
+    ///
+    public interface IDescriptor
+	{
+		// Whether the expansion of this descriptor depends on the position.
+		bool IsRange { get; }
+
+		// Whether this descriptor has all information about signing ignoring lack of private keys.
+		//  This is true for all descriptors except ones that use `raw` or `addr` constructions.
+		bool IsSolvable { get; }
+
+		// Whether this descriptor will return one scriptPubKey or multiple (aka is or is not combo)
+		bool IsSingleType { get; }
+
+		// Convert the descriptor to a private string. This fails if the provided provider does not have the relevant private keys.
+		bool ToPrivateString(SigningProvider provider, out string o);
+
+		// Expand a descriptor at a specified position.
+		//
+		// @param[in] pos The position at which to expand the descriptor. If IsRange() is false, this is ignored.
+		// @param[in] provider The provider to query for private keys in case of hardened derivation.
+		// @param[out] output_scripts The expanded scriptPubKeys.
+		// @param[out] out Scripts and public keys necessary for solving the expanded scriptPubKeys (may be equal to `provider`).
+		// @param[out] write_cache Cache data necessary to evaluate the descriptor at this point without access to private keys.
+		///
+		bool Expand(int pos, SigningProvider provider, Script output_scripts, FlatSigningProvider output, DescriptorCache* write_cache = nullptr);
+
+		// Expand a descriptor at a specified position using cached expansion data.
+		//
+		// @param[in] pos The position at which to expand the descriptor. If IsRange() is false, this is ignored.
+		// @param[in] read_cache Cached expansion data.
+		// @param[out] output_scripts The expanded scriptPubKeys.
+		// @param[out] out Scripts and public keys necessary for solving the expanded scriptPubKeys (may be equal to `provider`).
+		///
+		bool ExpandFromCache(int pos, DescriptorCache read_cache, Script output_scripts, FlatSigningProvider output);
+
+		// Expand the private key for a descriptor at a specified position, if possible.
+		//
+		// @param[in] pos The position at which to expand the descriptor. If IsRange() is false, this is ignored.
+		// @param[in] provider The provider to query for the private keys.
+		// @param[out] out Any private keys available for the specified `pos`.
+		///
+		void ExpandPrivate(int pos, SigningProvider provider, FlatSigningProvider output);
+
+		// @return The OutputType of the scriptPubKey(s) produced by this descriptor. Or nullopt if indeterminate (multiple or none)
+		OutputType? GetOutputType();
+	}
+}
\ No newline at end of file
diff --git a/NBitcoin/Scripting/MultisigDescriptor.cs b/NBitcoin/Scripting/MultisigDescriptor.cs
new file mode 100644
index 0000000000..f679b0e14d
--- /dev/null
+++ b/NBitcoin/Scripting/MultisigDescriptor.cs
@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+
+namespace NBitcoin.Scripting
+{
+    /** A parsed multi(...) or sortedmulti(...) descriptor */
+    class MultisigDescriptor : DescriptorImpl
+	{
+		private int m_threshold;
+		private bool m_sorted;
+	
+		protected string ToStringExtra()  { return strprintf("%i", m_threshold); }
+		protected List<Script> MakeScripts(List<PubKey> keys, Script script, out FlatSigningProvider output)  {
+			if (m_sorted) {
+				List<PubKey> sorted_keys(keys);
+				std::sort(sorted_keys.begin(), sorted_keys.end());
+				return Vector(GetScriptForMultisig(m_threshold, sorted_keys));
+			}
+			return Vector(GetScriptForMultisig(m_threshold, keys));
+		}
+	
+		public MultisigDescriptor(int threshold, List<std::unique_ptr<PubkeyProvider>> providers, bool sorted = false) 
+			: base(providers, null, sorted ? "sortedmulti" : "multi")
+			{
+				m_threshold = threshold;
+				m_sorted = sorted;
+			} 
+		public bool IsSingleType(){ return true; }
+	}
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/OriginPubkeyProvider.cs b/NBitcoin/Scripting/OriginPubkeyProvider.cs
new file mode 100644
index 0000000000..83b5148291
--- /dev/null
+++ b/NBitcoin/Scripting/OriginPubkeyProvider.cs
@@ -0,0 +1,43 @@
+namespace NBitcoin.Scripting
+{
+    public class OriginPubkeyProvider :  PubkeyProvider
+	{
+		private KeyOriginInfo m_origin;
+		private std::unique_ptr<PubkeyProvider> m_provider;
+
+		private string OriginString()
+		{
+			return HexStr(m_origin.fingerprint) + FormatHDKeypath(m_origin.path);
+		}
+
+	
+		public OriginPubkeyProvider(uint exp_index, KeyOriginInfo info, std::unique_ptr<PubkeyProvider> provider) 
+			: base(exp_index)
+	 	{ 
+			m_origin = info;
+			m_provider = provider;
+		}
+
+		public bool GetPubKey(int pos, SigningProvider arg, PubKey key, KeyOriginInfo info, DescriptorCache read_cache = null, DescriptorCache write_cache = null) 
+		{
+			if (!m_provider.GetPubKey(pos, arg, key, info, read_cache, write_cache)) 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;
+		}
+		public bool IsRange()  { return m_provider.IsRange(); }
+		public uint GetSize()  { return m_provider.GetSize(); }
+		public string ToString()  { return "[" + OriginString() + "]" + m_provider.ToString(); }
+		public bool ToPrivateString(SigningProvider arg, string ret) 
+		{
+			string sub;
+			if (!m_provider.ToPrivateString(arg, sub)) return false;
+			ret = "[" + OriginString() + "]" + sub;
+			return true;
+		}
+		public bool GetPrivKey(int pos, SigningProvider arg, Key key) 
+		{
+			return m_provider.GetPrivKey(pos, arg, key);
+		}
+	}
+} 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/PKDescriptor.cs b/NBitcoin/Scripting/PKDescriptor.cs
new file mode 100644
index 0000000000..d9badde6c7
--- /dev/null
+++ b/NBitcoin/Scripting/PKDescriptor.cs
@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace NBitcoin.Scripting
+{
+    /** A parsed pk(P) descriptor. */
+    public class PKDescriptor : DescriptorImpl
+	{
+		protected List<Script> MakeScripts(List<PubKey> keys, Script script, FlatSigningProvider signingProvider)  { return Vector(GetScriptForRawPubKey(keys[0])); }
+
+		public PKDescriptor(std::unique_ptr<PubkeyProvider> prov) : base(Vector(prov), null, "pk") {}
+		public bool IsSingleType(){ return true; }
+	};
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/PKHDescriptor.cs b/NBitcoin/Scripting/PKHDescriptor.cs
new file mode 100644
index 0000000000..c017c81da9
--- /dev/null
+++ b/NBitcoin/Scripting/PKHDescriptor.cs
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+
+namespace NBitcoin.Scripting
+{
+    /** A parsed pkh(P) descriptor. */
+    class PKHDescriptor :DescriptorImpl
+	{
+		protected List<Script> MakeScripts(List<PubKey> keys, Script*, FlatSigningProvider output) 
+		{
+			KeyID id = keys[0].GetID();
+			out.pubkeys.emplace(id, keys[0]);
+			return Vector(GetScriptForDestination(PKHash(id)));
+		}
+	
+		public PKHDescriptor(std::unique_ptr<PubkeyProvider> prov) : base(Vector(prov), null, "pkh") {}
+		public Optional<OutputType> GetOutputType()  { return OutputType::LEGACY; }
+		public bool IsSingleType(){ return true; }
+	};
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/ParseScriptContext.cs b/NBitcoin/Scripting/ParseScriptContext.cs
new file mode 100644
index 0000000000..cee31e5a34
--- /dev/null
+++ b/NBitcoin/Scripting/ParseScriptContext.cs
@@ -0,0 +1,12 @@
+namespace NBitcoin.Scripting
+{
+    ////////////////////////////////////////////////////////////////////////////
+    // Parser                                                                 //
+    ////////////////////////////////////////////////////////////////////////////
+
+    public enum ParseScriptContext {
+		TOP,
+		P2SH,
+		P2WSH,
+	}
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/PubkeyProvider.cs b/NBitcoin/Scripting/PubkeyProvider.cs
new file mode 100644
index 0000000000..4c64ca5896
--- /dev/null
+++ b/NBitcoin/Scripting/PubkeyProvider.cs
@@ -0,0 +1,39 @@
+namespace NBitcoin.Scripting
+{
+    /** Interface for public key objects in descriptors. */
+    public abstract class  PubkeyProvider
+	{
+		//! Index of this key expression in the descriptor
+		//! E.g. If this PubkeyProvider is key1 in multi(2, key1, key2, key3), then m_expr_index = 0
+		protected uint m_expr_index;
+
+		public PubkeyProvider(uint exp_index) 
+		{
+			m_expr_index = exp_index;
+		}
+
+		public abstract ~PubkeyProvider();
+
+		/** Derive a public key.
+		*  read_cache is the cache to read keys from (if not null)
+		*  write_cache is the cache to write keys to (if not null)
+		*  Caches are not exclusive but this is not tested. Currently we use them exclusively
+		*/
+		public abstract bool GetPubKey(int pos, SigningProvider arg, PubKey key, KeyOriginInfo info, DescriptorCache read_cache = null, DescriptorCache write_cache = null);
+
+		/** Whether this represent multiple public keys at different positions. */
+		public abstract bool IsRange();
+
+		/** Get the size of the generated public key(s) in bytes (33 or 65). */
+		public abstract uint GetSize();
+
+		/** Get the descriptor string form. */
+		public abstract string ToString();
+
+		/** Get the descriptor string form including private data (if available in arg). */
+		public abstract bool ToPrivateString(SigningProvider arg, string output);
+
+		/** Derive a private key, if private data is available in arg. */
+		public abstract bool GetPrivKey(int pos, SigningProvider arg, Key key);
+	};
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/RawDescriptor.cs b/NBitcoin/Scripting/RawDescriptor.cs
new file mode 100644
index 0000000000..85af2fc96d
--- /dev/null
+++ b/NBitcoin/Scripting/RawDescriptor.cs
@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+
+namespace NBitcoin.Scripting
+{
+    /** A parsed raw(H) descriptor. */
+    class RawDescriptor : DescriptorImpl
+	{
+		private Script m_script;
+	
+		protected string ToStringExtra()  { return HexStr(m_script); }
+		protected List<Script> MakeScripts(List<PubKey> pubkeys, Script script, FlatSigningProvider signingProvider)  { return Vector(m_script); }
+	
+		public RawDescriptor(Script script) : base(null, null, "raw")
+		{
+			m_script = script;
+		}
+		public bool IsSolvable(){ return false; }
+
+		public Optional<OutputType> GetOutputType() 
+		{
+			IDestination dest;
+			ExtractDestination(m_script, dest);
+			switch (dest.which()) {
+				case 1 /* PKHash */:
+				case 2 /* ScriptHash */: return OutputType::LEGACY;
+				case 3 /* WitnessV0ScriptHash */:
+				case 4 /* WitnessV0KeyHash */:
+				case 5 /* WitnessUnknown */: return OutputType::BECH32;
+				case 0 /* CNoDestination */:
+				default: return nullopt;
+			}
+		}
+		public bool IsSingleType(){ return true; }
+	};
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/SHDescriptor.cs b/NBitcoin/Scripting/SHDescriptor.cs
new file mode 100644
index 0000000000..1faa2101d2
--- /dev/null
+++ b/NBitcoin/Scripting/SHDescriptor.cs
@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+
+namespace NBitcoin.Scripting
+{
+    /** A parsed sh(...) descriptor. */
+    public class SHDescriptor : DescriptorImpl
+	{
+		protected List<Script> MakeScripts(List<PubKey> keys, Script script script, out FlatSigningProvider output)  { return Vector(GetScriptForDestination(ScriptHash(script))); }
+	
+		public SHDescriptor(std::unique_ptr<DescriptorImpl> desc) : base(null, desc, "sh") {}
+
+		public Optional<OutputType> GetOutputType() 
+		{
+			assert(m_subdescriptor_arg);
+			if (m_subdescriptor_arg.GetOutputType() == OutputType::BECH32) return OutputType::P2SH_SEGWIT;
+			return OutputType::LEGACY;
+		}
+		public bool IsSingleType(){ return true; }
+	};
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/WPKHDescriptor.cs b/NBitcoin/Scripting/WPKHDescriptor.cs
new file mode 100644
index 0000000000..7018edc6bb
--- /dev/null
+++ b/NBitcoin/Scripting/WPKHDescriptor.cs
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+
+namespace NBitcoin.Scripting
+{
+    /** A parsed wpkh(P) descriptor. */
+    class WPKHDescriptor :DescriptorImpl
+	{
+		protected List<Script> MakeScripts(List<PubKey> keys, Script script, out FlatSigningProvider output) 
+		{
+			KeyID id = keys[0].GetID();
+			out.pubkeys.emplace(id, keys[0]);
+			return Vector(GetScriptForDestination(WitnessV0KeyHash(id)));
+		}
+	
+		public WPKHDescriptor(std::unique_ptr<PubkeyProvider> prov) : base(Vector(prov), null, "wpkh") {}
+		publicOptional<OutputType> GetOutputType()  { return OutputType::BECH32; }
+		publicbool IsSingleType(){ return true; }
+	}
+                } 
\ No newline at end of file
diff --git a/NBitcoin/Scripting/WSHDescriptor.cs b/NBitcoin/Scripting/WSHDescriptor.cs
new file mode 100644
index 0000000000..f15bfc0d11
--- /dev/null
+++ b/NBitcoin/Scripting/WSHDescriptor.cs
@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace NBitcoin.Scripting
+{
+    /** A parsed wsh(...) descriptor. */
+    public class WSHDescriptor : DescriptorImpl
+	{
+		protected List<Script> MakeScripts(List<PubKey> keys, Script script, out FlatSigningProvider output)  { return Vector(GetScriptForDestination(WitnessV0ScriptHash(script))); }
+
+		public WSHDescriptor(std::unique_ptr<DescriptorImpl> desc) : base(null, desc, "wsh") {}
+		public Optional<OutputType> GetOutputType()  { return OutputType::BECH32; }
+		public bool IsSingleType() { return true; }
+	}
+                } 
\ No newline at end of file