diff --git a/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs b/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
new file mode 100644
index 0000000000..48b01ec65c
--- /dev/null
+++ b/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
@@ -0,0 +1,141 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Threading;
+using FsCheck;
+using NBitcoin.Scripting.Miniscript;
+using NBitcoin.Scripting.Miniscript.Policy;
+
+namespace NBitcoin.Tests.Generators
+{
+	public class ConcretePolicyGenerator
+	{
+		public static Arbitrary<ConcretePolicy<PubKey, uint160>> PubKeyConcretePolicyArb()
+			=> new ArbitraryPubKeyConcretePolicy();
+
+		public class ArbitraryPubKeyConcretePolicy : Arbitrary<ConcretePolicy<PubKey, uint160>>
+		{
+			public override Gen<ConcretePolicy<PubKey, uint160>> Generator => Gen.Sized(ConcretePolicyGen);
+
+			/*
+			public override IEnumerable<ConcretePolicy<PubKey, uint160>> Shrinker(ConcretePolicy<PubKey, uint160> parent)
+			{
+				switch (parent)
+				{
+					case ConcretePolicy<PubKey, uint160>.And p:
+						foreach (var i in p.Item)
+							yield return i;
+						foreach (var i in Arb.Shrink(p.Item))
+							if (i.Count == 2)
+								yield return ConcretePolicy<PubKey, uint160>.NewAnd(i);
+						break;
+					case ConcretePolicy<PubKey, uint160>.Or p:
+						foreach (var i in p.Item)
+							yield return i.Item2;
+						foreach (var i in Arb.Shrink(p.Item))
+							if (i.Count == 2)
+								yield return ConcretePolicy<PubKey, uint160>.NewOr(i);
+						break;
+					case ConcretePolicy<PubKey, uint160>.Threshold p:
+						foreach (var subP in p.Item2)
+						{
+							yield return subP;
+						}
+						foreach (var i in Arb.Shrink(p.Item2).Select(s => s.Select(sub => Shrinker(sub))))
+						{
+							foreach (var i2 in i)
+								if (1 < i2.Count())
+									yield return ConcretePolicy<PubKey, uint160>.NewThreshold(1, i2);
+						}
+
+						foreach (var subP in Arb.Shrink(p.Item2))
+						{
+							if (1 < subP.Count())
+								yield return ConcretePolicy<PubKey, uint160>.NewThreshold(1, subP);
+						}
+						yield break;
+				}
+			}
+			*/
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> ConcretePolicyGen(int size)
+			{
+				if (size == 0) return NonRecursivePolicyGen();
+				return Gen.Frequency(
+					Tuple.Create(3, NonRecursivePolicyGen()),
+					Tuple.Create(2, RecursivePolicyGen(size / 2))
+					);
+			}
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> NonRecursivePolicyGen()
+				=> Gen.OneOf(new[]
+				{
+					KeyGen(),
+					AfterGen(),
+					OlderGen(),
+					Sha256Gen(),
+					Hash256Gen(),
+					Ripemd160Gen(),
+					Hash160Gen()
+				});
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> KeyGen()
+				=>
+					from inner in CryptoGenerator.PublicKey()
+					select ConcretePolicy<PubKey, uint160>.NewKey(inner);
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> AfterGen()
+				=>
+					from t in Arb.Generate<PositiveInt>()
+					select ConcretePolicy<PubKey, uint160>.NewAfter((uint)t.Get);
+			private static Gen<ConcretePolicy<PubKey, uint160>> OlderGen()
+				=>
+					from t in Arb.Generate<PositiveInt>()
+					select ConcretePolicy<PubKey, uint160>.NewOlder((uint)t.Get);
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> Sha256Gen()
+				=>
+					from t in CryptoGenerator.Hash256()
+					select ConcretePolicy<PubKey, uint160>.NewSha256(t);
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> Hash256Gen()
+				=>
+					from t in CryptoGenerator.Hash256()
+					select ConcretePolicy<PubKey, uint160>.NewHash256(t);
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> Ripemd160Gen()
+				=>
+					from t in CryptoGenerator.Hash160()
+					select ConcretePolicy<PubKey, uint160>.NewRipemd160(t);
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> Hash160Gen()
+				=>
+					from t in CryptoGenerator.Hash160()
+					select ConcretePolicy<PubKey, uint160>.NewHash160(t);
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> RecursivePolicyGen(int size)
+				=>
+					Gen.OneOf(
+					(from sub in ConcretePolicyGen(size).Two()
+					select ConcretePolicy<PubKey, uint160>.NewAnd(new[] {sub.Item1, sub.Item2})),
+					(from prob in Arb.Generate<PositiveInt>().Two()
+					from sub in ConcretePolicyGen(size).Two()
+					select ConcretePolicy<PubKey, uint160>.NewOr(
+						new []{
+						Tuple.Create((uint)prob.Item1.Get, sub.Item1),
+						Tuple.Create((uint)prob.Item2.Get, sub.Item2)
+						})),
+					(from t in ThresholdContentsGen(size)
+					select ConcretePolicy<PubKey, uint160>.NewThreshold(t.Item1, t.Item2))
+					);
+
+			private static Gen<Tuple<uint, ConcretePolicy<PubKey, uint160>[]>> ThresholdContentsGen(int size)
+				=>
+					from n in Gen.Choose(1, 6)
+					from actualN in n == 1 ? Gen.Choose(2, 6) : Gen.Choose(n, 6)
+					from a in Gen.ArrayOf(actualN, ConcretePolicyGen(size))
+					select Tuple.Create((uint) n, a);
+		}
+	}
+
+}
diff --git a/NBitcoin.Tests/Generators/CryptoGenerator.cs b/NBitcoin.Tests/Generators/CryptoGenerator.cs
index f3f8f2bfa8..fe13bd8959 100644
--- a/NBitcoin.Tests/Generators/CryptoGenerator.cs
+++ b/NBitcoin.Tests/Generators/CryptoGenerator.cs
@@ -1,98 +1,102 @@
-using System;
-using NBitcoin;
-using FsCheck;
-using System.Collections.Generic;
-using Microsoft.FSharp.Collections;
-using System.Linq;
-using NBitcoin.Crypto;
-
-namespace NBitcoin.Tests.Generators
-{
-	public class CryptoGenerator
-	{
-		#region PrivateKey
-		public static Arbitrary<Key> KeysArb() =>
-			 Arb.From(PrivateKey());
-
-		public static Arbitrary<ExtKey> ExtKeysArb() =>
-			Arb.From(ExtKey());
-
-		public static Arbitrary<List<Key>> KeysListArb() =>
-			Arb.From(PrivateKeys(15));
-
-		public static Arbitrary<KeyPath> ExtPathArb() =>
-			Arb.From(KeyPath());
-
-		public static Gen<Key> PrivateKey() => Gen.Fresh(() => new Key());
-
-		public static Gen<List<Key>> PrivateKeys(int n) =>
-			from pk in Gen.ListOf<Key>(n, PrivateKey())
-			select pk.ToList();
-
-		#endregion
-
-		public static Gen<PubKey> PublicKey() =>
-			PrivateKey().Select(p => p.PubKey);
-
-		public static Gen<List<PubKey>> PublicKeys() =>
-			from n in Gen.Choose(0, 15)
-			from pks in PublicKeys(n)
-			select pks;
-
-		public static Gen<List<PubKey>> PublicKeys(int n) =>
-			from pks in Gen.ListOf(n, PublicKey())
-			select pks.ToList();
-
-		#region hash
-		public static Gen<uint256> Hash256() =>
-			from bytes in PrimitiveGenerator.RandomBytes(32)
-			select new uint256(bytes);
-
-		public static Gen<uint160> Hash160() =>
-			from bytes in PrimitiveGenerator.RandomBytes(20)
-			select new uint160(bytes);
-		#endregion
-
-		#region ECDSASignature
-		public static Gen<ECDSASignature> ECDSA() =>
-			from hash in Hash256()
-			from priv in PrivateKey()
-			select priv.Sign(hash);
-
-		public static Gen<List<ECDSASignature>> ECDSAs() =>
-			from n in Gen.Choose(0, 20)
-			from sigs in ECDSAs(n)
-			select sigs.ToList();
-
-		public static Gen<List<ECDSASignature>> ECDSAs(int n) =>
-			from sigs in Gen.ListOf(n, ECDSA())
-			select sigs.ToList();
-		#endregion
-
-		#region TransactionSignature
-		public static Gen<TransactionSignature> TransactionSignature() =>
-			from rawsig in ECDSA()
-			from sighash in SigHashType()
-			select new TransactionSignature(rawsig, sighash);
-
-		public static Gen<SigHash> SigHashType() =>
-			Gen.OneOf<SigHash>(new List<Gen<SigHash>> {
-				Gen.Constant(SigHash.All),
-				Gen.Constant(SigHash.Single),
-				Gen.Constant(SigHash.None),
-				Gen.Constant(SigHash.AnyoneCanPay | SigHash.All),
-				Gen.Constant(SigHash.AnyoneCanPay | SigHash.Single),
-				Gen.Constant(SigHash.AnyoneCanPay | SigHash.None)
-			});
-		#endregion
-
-		public static Gen<ExtKey> ExtKey() => Gen.Fresh(() => new ExtKey());
-
-		public static Gen<KeyPath> KeyPath() =>
-			from raw in Gen.NonEmptyListOf(PrimitiveGenerator.RandomBytes(4))
-			let flattenBytes = raw.ToList().Aggregate((a, b) => a.Concat(b))
-			select NBitcoin.KeyPath.FromBytes(flattenBytes);
-
-		public static Gen<ExtPubKey> ExtPubKey() => ExtKey().Select(ek => ek.Neuter());
-	}
-}
\ No newline at end of file
+using System;
+using NBitcoin;
+using FsCheck;
+using System.Collections.Generic;
+using Microsoft.FSharp.Collections;
+using System.Linq;
+using NBitcoin.Crypto;
+
+namespace NBitcoin.Tests.Generators
+{
+	public class CryptoGenerator
+	{
+		#region PrivateKey
+		public static Arbitrary<Key> KeysArb() =>
+			 Arb.From(PrivateKey());
+
+		public static Arbitrary<ExtKey> ExtKeysArb() =>
+			Arb.From(ExtKey());
+
+		public static Arbitrary<List<Key>> KeysListArb() =>
+			Arb.From(PrivateKeys(15));
+
+		public static Arbitrary<KeyPath> ExtPathArb() =>
+			Arb.From(KeyPath());
+
+
+		public static Arbitrary<PubKey> PubKeyArb() =>
+			Arb.From(PublicKey());
+
+		public static Gen<Key> PrivateKey() => Gen.Fresh(() => new Key());
+
+		public static Gen<List<Key>> PrivateKeys(int n) =>
+			from pk in Gen.ListOf<Key>(n, PrivateKey())
+			select pk.ToList();
+
+		#endregion
+
+		public static Gen<PubKey> PublicKey() =>
+			PrivateKey().Select(p => p.PubKey);
+
+		public static Gen<List<PubKey>> PublicKeys() =>
+			from n in Gen.Choose(0, 15)
+			from pks in PublicKeys(n)
+			select pks;
+
+		public static Gen<List<PubKey>> PublicKeys(int n) =>
+			from pks in Gen.ListOf(n, PublicKey())
+			select pks.ToList();
+
+		#region hash
+		public static Gen<uint256> Hash256() =>
+			from bytes in PrimitiveGenerator.RandomBytes(32)
+			select new uint256(bytes);
+
+		public static Gen<uint160> Hash160() =>
+			from bytes in PrimitiveGenerator.RandomBytes(20)
+			select new uint160(bytes);
+		#endregion
+
+		#region ECDSASignature
+		public static Gen<ECDSASignature> ECDSA() =>
+			from hash in Hash256()
+			from priv in PrivateKey()
+			select priv.Sign(hash);
+
+		public static Gen<List<ECDSASignature>> ECDSAs() =>
+			from n in Gen.Choose(0, 20)
+			from sigs in ECDSAs(n)
+			select sigs.ToList();
+
+		public static Gen<List<ECDSASignature>> ECDSAs(int n) =>
+			from sigs in Gen.ListOf(n, ECDSA())
+			select sigs.ToList();
+		#endregion
+
+		#region TransactionSignature
+		public static Gen<TransactionSignature> TransactionSignature() =>
+			from rawsig in ECDSA()
+			from sighash in SigHashType()
+			select new TransactionSignature(rawsig, sighash);
+
+		public static Gen<SigHash> SigHashType() =>
+			Gen.OneOf<SigHash>(new List<Gen<SigHash>> {
+				Gen.Constant(SigHash.All),
+				Gen.Constant(SigHash.Single),
+				Gen.Constant(SigHash.None),
+				Gen.Constant(SigHash.AnyoneCanPay | SigHash.All),
+				Gen.Constant(SigHash.AnyoneCanPay | SigHash.Single),
+				Gen.Constant(SigHash.AnyoneCanPay | SigHash.None)
+			});
+		#endregion
+
+		public static Gen<ExtKey> ExtKey() => Gen.Fresh(() => new ExtKey());
+
+		public static Gen<KeyPath> KeyPath() =>
+			from raw in Gen.NonEmptyListOf(PrimitiveGenerator.RandomBytes(4))
+			let flattenBytes = raw.ToList().Aggregate((a, b) => a.Concat(b))
+			select NBitcoin.KeyPath.FromBytes(flattenBytes);
+
+		public static Gen<ExtPubKey> ExtPubKey() => ExtKey().Select(ek => ek.Neuter());
+	}
+}
diff --git a/NBitcoin.Tests/Generators/PSBTGenerator.cs b/NBitcoin.Tests/Generators/PSBTGenerator.cs
index 639f220060..e1962786da 100644
--- a/NBitcoin.Tests/Generators/PSBTGenerator.cs
+++ b/NBitcoin.Tests/Generators/PSBTGenerator.cs
@@ -1,109 +1,109 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using FsCheck;
-using NBitcoin.Crypto;
-using Xunit;
-
-namespace NBitcoin.Tests.Generators
-{
-	using HDKeyPathKVMap = Dictionary<PubKey, Tuple<HDFingerprint, KeyPath>>;
-	using PartialSigKVMap = Dictionary<KeyId, Tuple<PubKey, ECDSASignature>>;
-	using UnknownKVMap = Dictionary<byte[], byte[]>;
-	public class PSBTGenerator
-	{
-		public static Arbitrary<PSBT> PSBTArb() => Arb.From(SanePSBT());
-
-		#region PSBTInput
-
-		public static Gen<Dictionary<KeyId, Tuple<PubKey, ECDSASignature>>> PartialSigs() =>
-								from itemNum in Gen.Choose(0, 15)
-								from sigs in CryptoGenerator.ECDSAs(itemNum)
-								from pks in CryptoGenerator.PublicKeys(itemNum)
-								let items = pks.ToList().Zip(sigs.ToList(), (pk, sig) => Tuple.Create(pk, sig)).ToList()
-								select Utils.DictionaryFromList<KeyId, Tuple<PubKey, ECDSASignature>>(pks.Select(pk => pk.Hash).ToList(), items);
-
-		#endregion
-
-		#region PSBT
-
-		public static Gen<PSBT> SanePSBT() =>
-			from network in ChainParamsGenerator.NetworkGen()
-			from psbt in SanePSBT(network)
-			select psbt;
-
-		/// <summary>
-		/// This is slow, provably because `Add*` methods will iterate over inputs.
-		/// </summary>
-		/// <param name="network"></param>
-		/// <returns></returns>
-		public static Gen<PSBT> SanePSBT(Network network) =>
-			from inputN in Gen.Choose(0, 8)
-			from scripts in Gen.ListOf(inputN, ScriptGenerator.RandomScriptSig())
-			from txOuts in Gen.Sequence(scripts.Select(sc => OutputFromRedeem(sc)))
-			from prevN in Gen.Choose(0, 5)
-			from prevTxs in Gen.Sequence(txOuts.Select(o => TXFromOutput(o, network, prevN)))
-			let txins = prevTxs.Select(tx => new TxIn(new OutPoint(tx.GetHash(), prevN)))
-			from locktime in PrimitiveGenerator.UInt32()
-			let tx = LegacyTransactionGenerators.ComposeTx(network.CreateTransaction(), txins.ToList(), txOuts.ToList(), locktime)
-			from TxsToAdd in Gen.SubListOf(prevTxs)
-			from CoinsToAdd in Gen.SubListOf(prevTxs.SelectMany(tx => tx.Outputs.AsCoins()))
-			from scriptsToAdd in Gen.SubListOf<Script>(scripts)
-			let psbt = tx.CreatePSBT(network)
-				.AddTransactions(prevTxs.ToArray())
-				.AddCoins(CoinsToAdd.ToArray())
-				.AddScripts(scriptsToAdd.ToArray())
-			select psbt;
-
-		private static Gen<TxOut> OutputFromRedeemOrKey(Script sc, PubKey key) =>
-			sc != null ? OutputFromRedeem(sc) : OutputFromKey(key);
-
-		private static Gen<TxOut> OutputFromKey(PubKey key) =>
-			from money in MoneyGenerator.Money()
-			from isP2WPKH in PrimitiveGenerator.Bool()
-			from isP2SH in PrimitiveGenerator.Bool()
-			let scriptPubKey = (isP2SH && isP2WPKH) ? key.WitHash.ScriptPubKey.Hash.ScriptPubKey : isP2WPKH ? key.WitHash.ScriptPubKey : key.Hash.ScriptPubKey
-			select new TxOut(money, scriptPubKey);
-		private static Gen<TxOut> OutputFromRedeem(Script sc) =>
-			from money in MoneyGenerator.Money()
-			from isP2WSH in PrimitiveGenerator.Bool()
-			from isP2SH in PrimitiveGenerator.Bool()
-			where isP2WSH || isP2SH
-			let redeem = (isP2SH && isP2WSH) ? sc.WitHash.ScriptPubKey : sc
-			let scriptPubKey = isP2SH ? redeem.Hash.ScriptPubKey : redeem.WitHash.ScriptPubKey
-			select new TxOut(money, scriptPubKey);
-
-		private static Gen<Transaction> TXFromOutput(TxOut txout, Network network, int vout) =>
-			from outNum in Gen.Choose(0, 4)
-			from tx in SegwitTransactionGenerators.TX(network)
-			where tx.Outputs.Count > vout
-			select ReplaceTxOut(tx, txout, vout);
-
-		private static Transaction ReplaceTxOut(Transaction tx, TxOut txout, int index)
-		{
-			tx.Outputs[index] = txout;
-			return tx;
-		}
-
-		#endregion
-		public static Gen<UnknownKVMap> UnknownKVMap() =>
-				from itemNum in Gen.Choose(0, 15)
-				from keys in Gen.ListOf(itemNum, PrimitiveGenerator.RandomBytes())
-				where PSBTConstants.PSBT_IN_ALL.All(i => keys.Select(k => k.First()).All(k => k != i))
-				let uniqKeys = keys.Distinct()
-				from values in Gen.ListOf(uniqKeys.Count(), PrimitiveGenerator.RandomBytes())
-				select Utils.DictionaryFromList<byte[], byte[]>(uniqKeys.ToList(), values.ToList());
-
-		public static Gen<HDKeyPathKVMap> HDKeyPaths() =>
-				from itemNum in Gen.Choose(0, 15)
-				from pks in Gen.ListOf(itemNum, CryptoGenerator.PublicKey())
-				from map in HDKeyPaths(pks, itemNum)
-				select map;
-
-		public static Gen<HDKeyPathKVMap> HDKeyPaths(IEnumerable<PubKey> pks, int itemNum) =>
-				from MasterKeyFingerPrints in Gen.ListOf(itemNum, Utils.HDFingerprint())
-				from paths in Gen.ListOf(itemNum, CryptoGenerator.KeyPath())
-				let fingerPrintAndPath = MasterKeyFingerPrints.ToArray().Zip(paths.ToArray(), (m, p) => Tuple.Create(m, p)).ToList()
-				select Utils.DictionaryFromList<PubKey, Tuple<HDFingerprint, KeyPath>>(pks.ToList(), fingerPrintAndPath);
-	}
-}
\ No newline at end of file
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using FsCheck;
+using NBitcoin.Crypto;
+using Xunit;
+
+namespace NBitcoin.Tests.Generators
+{
+	using HDKeyPathKVMap = Dictionary<PubKey, Tuple<HDFingerprint, KeyPath>>;
+	using PartialSigKVMap = Dictionary<KeyId, Tuple<PubKey, ECDSASignature>>;
+	using UnknownKVMap = Dictionary<byte[], byte[]>;
+	public class PSBTGenerator
+	{
+		public static Arbitrary<PSBT> PSBTArb() => Arb.From(SanePSBT());
+
+		#region PSBTInput
+
+		public static Gen<Dictionary<KeyId, Tuple<PubKey, ECDSASignature>>> PartialSigs() =>
+								from itemNum in Gen.Choose(0, 15)
+								from sigs in CryptoGenerator.ECDSAs(itemNum)
+								from pks in CryptoGenerator.PublicKeys(itemNum)
+								let items = pks.ToList().Zip(sigs.ToList(), (pk, sig) => Tuple.Create(pk, sig)).ToList()
+								select Utils.DictionaryFromList<KeyId, Tuple<PubKey, ECDSASignature>>(pks.Select(pk => pk.Hash).ToList(), items);
+
+		#endregion
+
+		#region PSBT
+
+		public static Gen<PSBT> SanePSBT() =>
+			from network in ChainParamsGenerator.NetworkGen()
+			from psbt in SanePSBT(network)
+			select psbt;
+
+		/// <summary>
+		/// This is slow, provably because `Add*` methods will iterate over inputs.
+		/// </summary>
+		/// <param name="network"></param>
+		/// <returns></returns>
+		public static Gen<PSBT> SanePSBT(Network network) =>
+			from inputN in Gen.Choose(0, 8)
+			from scripts in Gen.ListOf(inputN, ScriptGenerator.RandomScriptSig())
+			from txOuts in Gen.Sequence(scripts.Select(sc => OutputFromRedeem(sc)))
+			from prevN in Gen.Choose(0, 5)
+			from prevTxs in Gen.Sequence(txOuts.Select(o => TXFromOutput(o, network, prevN)))
+			let txins = prevTxs.Select(tx => new TxIn(new OutPoint(tx.GetHash(), prevN)))
+			from locktime in PrimitiveGenerator.UInt32()
+			let tx = LegacyTransactionGenerators.ComposeTx(network.CreateTransaction(), txins.ToList(), txOuts.ToList(), locktime)
+			from TxsToAdd in Gen.SubListOf(prevTxs)
+			from CoinsToAdd in Gen.SubListOf(prevTxs.SelectMany(t => t.Outputs.AsCoins()))
+			from scriptsToAdd in Gen.SubListOf<Script>(scripts)
+			let psbt = tx.CreatePSBT(network)
+				.AddTransactions(prevTxs.ToArray())
+				.AddCoins(CoinsToAdd.ToArray())
+				.AddScripts(scriptsToAdd.ToArray())
+			select psbt;
+
+		private static Gen<TxOut> OutputFromRedeemOrKey(Script sc, PubKey key) =>
+			sc != null ? OutputFromRedeem(sc) : OutputFromKey(key);
+
+		private static Gen<TxOut> OutputFromKey(PubKey key) =>
+			from money in MoneyGenerator.Money()
+			from isP2WPKH in PrimitiveGenerator.Bool()
+			from isP2SH in PrimitiveGenerator.Bool()
+			let scriptPubKey = (isP2SH && isP2WPKH) ? key.WitHash.ScriptPubKey.Hash.ScriptPubKey : isP2WPKH ? key.WitHash.ScriptPubKey : key.Hash.ScriptPubKey
+			select new TxOut(money, scriptPubKey);
+		private static Gen<TxOut> OutputFromRedeem(Script sc) =>
+			from money in MoneyGenerator.Money()
+			from isP2WSH in PrimitiveGenerator.Bool()
+			from isP2SH in PrimitiveGenerator.Bool()
+			where isP2WSH || isP2SH
+			let redeem = (isP2SH && isP2WSH) ? sc.WitHash.ScriptPubKey : sc
+			let scriptPubKey = isP2SH ? redeem.Hash.ScriptPubKey : redeem.WitHash.ScriptPubKey
+			select new TxOut(money, scriptPubKey);
+
+		private static Gen<Transaction> TXFromOutput(TxOut txout, Network network, int vout) =>
+			from outNum in Gen.Choose(0, 4)
+			from tx in SegwitTransactionGenerators.TX(network)
+			where tx.Outputs.Count > vout
+			select ReplaceTxOut(tx, txout, vout);
+
+		private static Transaction ReplaceTxOut(Transaction tx, TxOut txout, int index)
+		{
+			tx.Outputs[index] = txout;
+			return tx;
+		}
+
+		#endregion
+		public static Gen<UnknownKVMap> UnknownKVMap() =>
+				from itemNum in Gen.Choose(0, 15)
+				from keys in Gen.ListOf(itemNum, PrimitiveGenerator.RandomBytes())
+				where PSBTConstants.PSBT_IN_ALL.All(i => keys.Select(k => k.First()).All(k => k != i))
+				let uniqKeys = keys.Distinct()
+				from values in Gen.ListOf(uniqKeys.Count(), PrimitiveGenerator.RandomBytes())
+				select Utils.DictionaryFromList<byte[], byte[]>(uniqKeys.ToList(), values.ToList());
+
+		public static Gen<HDKeyPathKVMap> HDKeyPaths() =>
+				from itemNum in Gen.Choose(0, 15)
+				from pks in Gen.ListOf(itemNum, CryptoGenerator.PublicKey())
+				from map in HDKeyPaths(pks, itemNum)
+				select map;
+
+		public static Gen<HDKeyPathKVMap> HDKeyPaths(IEnumerable<PubKey> pks, int itemNum) =>
+				from MasterKeyFingerPrints in Gen.ListOf(itemNum, Utils.HDFingerprint())
+				from paths in Gen.ListOf(itemNum, CryptoGenerator.KeyPath())
+				let fingerPrintAndPath = MasterKeyFingerPrints.ToArray().Zip(paths.ToArray(), (m, p) => Tuple.Create(m, p)).ToList()
+				select Utils.DictionaryFromList<PubKey, Tuple<HDFingerprint, KeyPath>>(pks.ToList(), fingerPrintAndPath);
+	}
+}
diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
new file mode 100644
index 0000000000..a85a8decfe
--- /dev/null
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -0,0 +1,416 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NBitcoin.DataEncoders;
+using NBitcoin.Scripting.Miniscript;
+using NBitcoin.Scripting.Miniscript.Policy;
+using NBitcoin.Scripting.Parser;
+using Xunit;
+using NBitcoin.Scripting.Miniscript.Types;
+
+namespace NBitcoin.Tests
+{
+	public class MiniscriptTests
+	{
+		public static HexEncoder Hex = new DataEncoders.HexEncoder();
+
+
+		public static Key[] PrivKeys = (new[]
+			{
+				"4040404040404040404040404040404040404040404040404040404040404040",
+				"4141414141414141414141414141414141414141414141414141414141414141",
+				"4242424242424242424242424242424242424242424242424242424242424242",
+				"4343434343434343434343434343434343434343434343434343434343434343",
+				"4444444444444444444444444444444444444444444444444444444444444444",
+				"4545454545454545454545454545454545454545454545454545454545454545",
+				"4646464646464646464646464646464646464646464646464646464646464646",
+				"4747474747474747474747474747474747474747474747474747474747474747"
+			}).Select(str => new Key(Hex.DecodeData(str))).ToArray();
+
+		public static PubKey[] PubKeys = PrivKeys.Select(k => k.PubKey).ToArray();
+
+		public static TheoryData<string, string, bool, bool, bool, uint, uint> MSAttributeTestCase =>
+			new TheoryData<string, string, bool, bool, bool, uint, uint>
+			{
+				{
+					"lltvln:after(1231488000)",
+					"6300676300676300670400046749b1926869516868",
+					true,
+					true,
+					false,
+					12,
+					3
+				},
+				{
+					"uuj:and_v(v:thresh_m(2,03d01115d548e7561b15c38f004d734633687cf4419620095bc5b0f47070afe85a,025601570cb47f238d2b0286db4a990fa0f3ba28d1a319f5e7cf55c2a2444da7cc),after(1231488000))",
+					"6363829263522103d01115d548e7561b15c38f004d734633687cf4419620095bc5b0f47070afe85a21025601570cb47f238d2b0286db4a990fa0f3ba28d1a319f5e7cf55c2a2444da7cc52af0400046749b168670068670068",
+					true, true, true, 14, 5
+				},
+				{
+					"or_b(un:thresh_m(2,03daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729,024ce119c96e2fa357200b559b2f7dd5a5f02d5290aff74b03f3e471b273211c97),al:older(16))",
+					"63522103daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee872921024ce119c96e2fa357200b559b2f7dd5a5f02d5290aff74b03f3e471b273211c9752ae926700686b63006760b2686c9b",
+					true, false, false, 14, 5
+				},
+				{
+					"j:and_v(vdv:after(1567547623),older(2016))",
+					"829263766304e7e06e5db169686902e007b268",
+					true,
+					true,
+					false,
+					11,
+					1
+				},
+				{
+					"t:and_v(vu:hash256(131772552c01444cd81360818376a040b7c3b2b7b0a53550ee3edde216cec61b),v:sha256(ec4916dd28fc4c10d78e287ca5d9cc51ee1ae73cbfde08c6b37324cbfaac8bc5))",
+					"6382012088aa20131772552c01444cd81360818376a040b7c3b2b7b0a53550ee3edde216cec61b876700686982012088a820ec4916dd28fc4c10d78e287ca5d9cc51ee1ae73cbfde08c6b37324cbfaac8bc58851",
+					true, true, false, 12, 3
+				},
+				{
+					"t:andor(thresh_m(3,02d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e,03fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556,02e493dbf1c10d80f3581e4904930b1404cc6c13900ee0758474fa94abe8c4cd13),v:older(4194305),v:sha256(9267d3dbed802941483f1afa2a6bc68de5f653128aca9bf1461c5d0a3ad36ed2))",
+					"532102d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e2103fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a14602975562102e493dbf1c10d80f3581e4904930b1404cc6c13900ee0758474fa94abe8c4cd1353ae6482012088a8209267d3dbed802941483f1afa2a6bc68de5f653128aca9bf1461c5d0a3ad36ed2886703010040b2696851",
+					true, true, false, 13, 5
+				},
+				{
+					"or_d(thresh_m(1,02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9),or_b(thresh_m(3,022f01e5e15cca351daff3843fb70f3c2f0a1bdd05e5af888a67784ef3e10a2a01,032fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f,03d01115d548e7561b15c38f004d734633687cf4419620095bc5b0f47070afe85a),su:after(500000)))",
+					"512102f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f951ae73645321022f01e5e15cca351daff3843fb70f3c2f0a1bdd05e5af888a67784ef3e10a2a0121032fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f2103d01115d548e7561b15c38f004d734633687cf4419620095bc5b0f47070afe85a53ae7c630320a107b16700689b68",
+					true, true, false, 15, 7
+				},
+				{
+					"or_d(sha256(38df1c1f64a24a77b23393bca50dff872e31edc4f3b5aa3b90ad0b82f4f089b6),and_n(un:after(499999999),older(4194305)))",
+					"82012088a82038df1c1f64a24a77b23393bca50dff872e31edc4f3b5aa3b90ad0b82f4f089b68773646304ff64cd1db19267006864006703010040b26868",
+					true, false, false, 16, 1
+				},
+				{
+					"and_v(or_i(v:thresh_m(2,02c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5,03774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb),v:thresh_m(2,03e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a,025cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc)),sha256(d1ec675902ef1633427ca360b290b0b3045a0d9058ddb5e648b4c3c3224c5c68))",
+					"63522102c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee52103774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb52af67522103e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a21025cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc52af6882012088a820d1ec675902ef1633427ca360b290b0b3045a0d9058ddb5e648b4c3c3224c5c6887",
+					true, true, true, 11, 5
+				},
+				{
+					"j:and_b(thresh_m(2,0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798,024ce119c96e2fa357200b559b2f7dd5a5f02d5290aff74b03f3e471b273211c97),s:or_i(older(1),older(4252898)))",
+					"82926352210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179821024ce119c96e2fa357200b559b2f7dd5a5f02d5290aff74b03f3e471b273211c9752ae7c6351b26703e2e440b2689a68",
+					true, false, true, 14, 4
+				},
+				{
+					"and_b(older(16),s:or_d(sha256(e38990d0c7fc009880a9c07c23842e886c6bbdc964ce6bdd5817ad357335ee6f),n:after(1567547623)))",
+					"60b27c82012088a820e38990d0c7fc009880a9c07c23842e886c6bbdc964ce6bdd5817ad357335ee6f87736404e7e06e5db192689a",
+					true, false, false, 12, 1
+				},
+				{
+					"j:and_v(v:hash160(20195b5a3d650c17f0f29f91c33f8f6335193d07),or_d(sha256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),older(16)))",
+					"82926382012088a91420195b5a3d650c17f0f29f91c33f8f6335193d078882012088a82096de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c4787736460b26868",
+					true, false, false, 16, 2
+				},
+				{
+					"and_b(hash256(32ba476771d01e37807990ead8719f08af494723de1d228f2c2c07cc0aa40bac),a:and_b(hash256(131772552c01444cd81360818376a040b7c3b2b7b0a53550ee3edde216cec61b),a:older(1)))",
+					"82012088aa2032ba476771d01e37807990ead8719f08af494723de1d228f2c2c07cc0aa40bac876b82012088aa20131772552c01444cd81360818376a040b7c3b2b7b0a53550ee3edde216cec61b876b51b26c9a6c9a",
+					true, true, false, 15, 2
+				},
+				{
+					"thresh(2,thresh_m(2,03a0434d9e47f3c86235477c7b1ae6ae5d3442d49b1943c2b752a68e2a47e247c7,036d2b085e9e382ed10b69fc311a03f8641ccfff21574de0927513a49d9a688a00),a:thresh_m(1,036d2b085e9e382ed10b69fc311a03f8641ccfff21574de0927513a49d9a688a00),ac:pk(022f01e5e15cca351daff3843fb70f3c2f0a1bdd05e5af888a67784ef3e10a2a01))",
+					"522103a0434d9e47f3c86235477c7b1ae6ae5d3442d49b1943c2b752a68e2a47e247c721036d2b085e9e382ed10b69fc311a03f8641ccfff21574de0927513a49d9a688a0052ae6b5121036d2b085e9e382ed10b69fc311a03f8641ccfff21574de0927513a49d9a688a0051ae6c936b21022f01e5e15cca351daff3843fb70f3c2f0a1bdd05e5af888a67784ef3e10a2a01ac6c935287",
+					true, true, true, 13, 6
+				},
+				{
+					"and_n(sha256(d1ec675902ef1633427ca360b290b0b3045a0d9058ddb5e648b4c3c3224c5c68),t:or_i(v:older(4252898),v:older(144)))",
+					"82012088a820d1ec675902ef1633427ca360b290b0b3045a0d9058ddb5e648b4c3c3224c5c68876400676303e2e440b26967029000b269685168",
+					true, false, false, 14, 2
+				},
+				{
+					"or_d(d:and_v(v:older(4252898),v:older(4252898)),sha256(38df1c1f64a24a77b23393bca50dff872e31edc4f3b5aa3b90ad0b82f4f089b6))",
+					"766303e2e440b26903e2e440b26968736482012088a82038df1c1f64a24a77b23393bca50dff872e31edc4f3b5aa3b90ad0b82f4f089b68768",
+					true, false, false, 14, 2
+				},
+				{
+					"c:and_v(or_c(sha256(9267d3dbed802941483f1afa2a6bc68de5f653128aca9bf1461c5d0a3ad36ed2),v:thresh_m(1,02c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db)),pk(03acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe))",
+					"82012088a8209267d3dbed802941483f1afa2a6bc68de5f653128aca9bf1461c5d0a3ad36ed28764512102c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db51af682103acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbeac",
+					true, false, true, 8, 2
+				},
+				{
+					"c:and_v(or_c(thresh_m(2,036d2b085e9e382ed10b69fc311a03f8641ccfff21574de0927513a49d9a688a00,02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5),v:ripemd160(1b0f3c404d12075c68c938f9f60ebea4f74941a0)),pk(03fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556))",
+					"5221036d2b085e9e382ed10b69fc311a03f8641ccfff21574de0927513a49d9a688a002102352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d552ae6482012088a6141b0f3c404d12075c68c938f9f60ebea4f74941a088682103fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556ac",
+					true, true, true, 10, 5
+				},
+				{
+					"and_v(andor(hash256(8a35d9ca92a48eaade6f53a64985e9e2afeb74dcf8acb4c3721e0dc7e4294b25),v:hash256(939894f70e6c3a25da75da0cc2071b4076d9b006563cf635986ada2e93c0d735),v:older(50000)),after(499999999))",
+					"82012088aa208a35d9ca92a48eaade6f53a64985e9e2afeb74dcf8acb4c3721e0dc7e4294b2587640350c300b2696782012088aa20939894f70e6c3a25da75da0cc2071b4076d9b006563cf635986ada2e93c0d735886804ff64cd1db1",
+					true, false, false, 14, 2
+				},
+				{
+					"andor(hash256(5f8d30e655a7ba0d7596bb3ddfb1d2d20390d23b1845000e1e118b3be1b3f040),j:and_v(v:hash160(3a2bff0da9d96868e66abc4427bea4691cf61ccd),older(4194305)),ripemd160(44d90e2d3714c8663b632fcf0f9d5f22192cc4c8))",
+					"82012088aa205f8d30e655a7ba0d7596bb3ddfb1d2d20390d23b1845000e1e118b3be1b3f040876482012088a61444d90e2d3714c8663b632fcf0f9d5f22192cc4c8876782926382012088a9143a2bff0da9d96868e66abc4427bea4691cf61ccd8803010040b26868",
+					true, false, false, 20, 2
+				},
+				{
+					"or_i(c:and_v(v:after(500000),pk(02c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5)),sha256(d9147961436944f43cd99d28b2bbddbf452ef872b30c8279e255e7daafc7f946))",
+					"630320a107b1692102c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5ac6782012088a820d9147961436944f43cd99d28b2bbddbf452ef872b30c8279e255e7daafc7f9468768",
+					true, true, false, 10, 2
+				},
+				{
+					"thresh(2,c:pk_h(5dedfbf9ea599dd4e3ca6a80b333c472fd0b3f69),s:sha256(e38990d0c7fc009880a9c07c23842e886c6bbdc964ce6bdd5817ad357335ee6f),a:hash160(dd69735817e0e3f6f826a9238dc2e291184f0131))",
+					"76a9145dedfbf9ea599dd4e3ca6a80b333c472fd0b3f6988ac7c82012088a820e38990d0c7fc009880a9c07c23842e886c6bbdc964ce6bdd5817ad357335ee6f87936b82012088a914dd69735817e0e3f6f826a9238dc2e291184f0131876c935287",
+					true, false, false, 18, 4
+				},
+				{
+					"and_n(sha256(9267d3dbed802941483f1afa2a6bc68de5f653128aca9bf1461c5d0a3ad36ed2),uc:and_v(v:older(144),pk(03fe72c435413d33d48ac09c9161ba8b09683215439d62b7940502bda8b202e6ce)))",
+					"82012088a8209267d3dbed802941483f1afa2a6bc68de5f653128aca9bf1461c5d0a3ad36ed28764006763029000b2692103fe72c435413d33d48ac09c9161ba8b09683215439d62b7940502bda8b202e6ceac67006868",
+					true, false, true, 13, 3
+				},
+				{
+					"and_n(c:pk(03daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729),and_b(l:older(4252898),a:older(16)))",
+					"2103daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729ac64006763006703e2e440b2686b60b26c9a68",
+					true, true, true, 12, 2
+				},
+				{
+					"c:or_i(and_v(v:older(16),pk_h(9fc5dbe5efdce10374a4dd4053c93af540211718)),pk_h(2fbd32c8dd59ee7c17e66cb6ebea7e9846c3040f))",
+					"6360b26976a9149fc5dbe5efdce10374a4dd4053c93af540211718886776a9142fbd32c8dd59ee7c17e66cb6ebea7e9846c3040f8868ac",
+					true, true, true, 12, 3
+				},
+				{
+					"or_d(c:pk_h(c42e7ef92fdb603af844d064faad95db9bcdfd3d),andor(c:pk(024ce119c96e2fa357200b559b2f7dd5a5f02d5290aff74b03f3e471b273211c97),older(2016),after(1567547623)))",
+					"76a914c42e7ef92fdb603af844d064faad95db9bcdfd3d88ac736421024ce119c96e2fa357200b559b2f7dd5a5f02d5290aff74b03f3e471b273211c97ac6404e7e06e5db16702e007b26868",
+					true, true, false, 13, 3
+				},
+				{
+					"c:andor(ripemd160(6ad07d21fd5dfc646f0b30577045ce201616b9ba),pk_h(9fc5dbe5efdce10374a4dd4053c93af540211718),and_v(v:hash256(8a35d9ca92a48eaade6f53a64985e9e2afeb74dcf8acb4c3721e0dc7e4294b25),pk_h(dd100be7d9aea5721158ebde6d6a1fd8fff93bb1)))",
+					"82012088a6146ad07d21fd5dfc646f0b30577045ce201616b9ba876482012088aa208a35d9ca92a48eaade6f53a64985e9e2afeb74dcf8acb4c3721e0dc7e4294b258876a914dd100be7d9aea5721158ebde6d6a1fd8fff93bb1886776a9149fc5dbe5efdce10374a4dd4053c93af5402117188868ac",
+					true, false, true, 18, 3
+				},
+				{
+					"c:andor(u:ripemd160(6ad07d21fd5dfc646f0b30577045ce201616b9ba),pk_h(20d637c1a6404d2227f3561fdbaff5a680dba648),or_i(pk_h(9652d86bedf43ad264362e6e6eba6eb764508127),pk_h(751e76e8199196d454941c45d1b3a323f1433bd6)))",
+					"6382012088a6146ad07d21fd5dfc646f0b30577045ce201616b9ba87670068646376a9149652d86bedf43ad264362e6e6eba6eb764508127886776a914751e76e8199196d454941c45d1b3a323f1433bd688686776a91420d637c1a6404d2227f3561fdbaff5a680dba6488868ac",
+					true, false, true, 23, 4
+				},
+				{
+					"c:or_i(andor(c:pk_h(fcd35ddacad9f2d5be5e464639441c6065e6955d),pk_h(9652d86bedf43ad264362e6e6eba6eb764508127),pk_h(06afd46bcdfd22ef94ac122aa11f241244a37ecc)),pk(02d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e))",
+					"6376a914fcd35ddacad9f2d5be5e464639441c6065e6955d88ac6476a91406afd46bcdfd22ef94ac122aa11f241244a37ecc886776a9149652d86bedf43ad264362e6e6eba6eb7645081278868672102d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e68ac",
+					true, true, true, 17, 5
+				},
+			};
+
+		[Theory]
+		[Trait("Core", "Core")]
+		[MemberData(nameof(MSAttributeTestCase))]
+		public void MiniscriptAttributesTest(
+			string msStr, string expectedHex, bool valid, bool nonMalleable,
+			bool needSig, uint ops, uint _stack)
+		{
+			Miniscript<PubKey, uint160> ms;
+			try
+			{
+				ms = Miniscript<PubKey, uint160>.Parse(msStr);
+				Assert.Equal(Script.FromHex(expectedHex), ms.ToScript());
+				Assert.Equal(expectedHex, ms.ToScript().ToHex());
+				Assert.Equal(nonMalleable, ms.Type.Malleability.NonMalleable);
+				Assert.Equal(needSig, ms.Type.Malleability.Safe);
+				Assert.Equal(ops, ms.Ext.OpsCountSat);
+				Assert.True(valid);
+			}
+			catch (ParsingException ex)
+			{
+				Assert.False(valid, ex.ToString());
+			}
+		}
+
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void TerminalUnitTest()
+		{
+			// must fail to type check
+			Assert.Throws<ParsingException>(() => Miniscript<PubKey, uint160>.Parse($"or_d(c:pk({PubKeys[0]}),pk({PubKeys[1]}))"));
+		}
+
+
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void PolicyParserTest()
+		{
+			ConcretePolicy<MiniscriptStringKey, MiniscriptStringKeyHash>.Parse("pk(foo)");
+
+			Assert.Throws<FormatException>(() => ConcretePolicy<PubKey, uint160>.Parse("pk(foo)"));
+			var msRealPK = ConcretePolicy<PubKey, uint160>.Parse($"pk({PubKeys[0]})");
+			Assert.True(msRealPK.AssertValid());
+
+			var strOr = $"or(99@pk({PubKeys[0]}),pk({PubKeys[1]}))";
+			var orRes = ConcretePolicy<PubKey, uint160>.Parse(strOr);
+			Assert.True(orRes.AssertValid());
+
+			var strNestedOr = $"or(after(3),{strOr})";
+			var nestedOrRes = ConcretePolicy<PubKey, uint160>.Parse(strNestedOr);
+			Assert.True(nestedOrRes.AssertValid());
+
+			var strAnd = $"and(older(3),{strNestedOr})";
+			var andRes = ConcretePolicy<PubKey, uint160>.Parse(strAnd);
+			Assert.True(andRes.AssertValid());
+
+			var hash256 = Crypto.Hashes.Hash256(PubKeys[2].ToBytes()).ToString();
+			var hash160 = Crypto.Hashes.Hash160(PubKeys[2].ToBytes()).ToString();
+			var strThresh = $"thresh(2,hash256({hash256}),{strAnd},hash160({hash160}))";
+			var threshRes = ConcretePolicy<PubKey, uint160>.Parse(strThresh);
+			Assert.True(threshRes.AssertValid());
+
+		}
+
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void ConcretePolicyUnitTest()
+		{
+			var testCase1 = "and(sha256(a12b09447802e01b4fd9b7f226b08e18538765ef2a5e3cc6a435139d7bb69dee),and(hash256(f0ce5893c7a52f6a9e7c06e41f53ddbbf62ab492cdb4ad69f620f84acf57a6a3),hash160(e21d51db6c8f9079fb9d2471fbd9639ed2630d33)))";
+			var concreteP1_1 = ConcretePolicy<PubKey, uint160>.Parse(testCase1);
+			var concreteP1_2 = ConcretePolicy<PubKey, uint160>.Parse(testCase1);
+			Assert.Equal(concreteP1_1, concreteP1_2);
+
+			var testCase2 = "and(ripemd160(a8cb8a3e2c696b51f3178711ef2a11f20554b107),pk(024aa5f11820cdf29e8aa46ec1f97def0538e12e5f9dd9a7693294570551f8ad9a))";
+			var concreteP2_1 = ConcretePolicy<PubKey, uint160>.Parse(testCase2);
+			var concreteP2_2 = ConcretePolicy<PubKey, uint160>.Parse(testCase2);
+			Assert.Equal(concreteP2_1.GetHashCode(), concreteP2_2.GetHashCode());
+		}
+
+		private void PolicyCompileLiftCheck(string s, string expected = null)
+		{
+			var policy = ConcretePolicy<PubKey, uint160>.Parse(s);
+			var ms = policy.Compile();
+			Assert.Equal(policy.Lift(), ms.Lift());
+			Assert.Equal(policy.Lift().GetHashCode(), ms.Lift().GetHashCode());
+			if (expected != null)
+			{
+				var expectedMs = Miniscript<PubKey, uint160>.Parse(expected);
+				Console.WriteLine(ms);
+				Assert.Equal(expectedMs.Node, ms.Node);
+			}
+		}
+
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void CompilerUnitTestInvalid()
+		{
+			// we cannot compile if the top level is not safe. (i.e. can spend by anyone.)
+			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck("after(9)"));
+			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck("older(1)"));
+			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck("sha256(1111111111111111111111111111111111111111111111111111111111111111)"));
+			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck($"thresh(2,after(9),after(9),pk({PubKeys[0]}))"));
+
+			// Impossible to compile with non-malleable form
+			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck($"and(pk({PubKeys[0]}),or(after(9),after(9)))"));
+		}
+
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void CompilerUnitTestValid()
+		{
+
+			// successful case
+			PolicyCompileLiftCheck(
+				$"and(pk({PubKeys[0]}),pk({PubKeys[1]}))",
+				$"c:and_v(vc:pk({PubKeys[0]}),pk({PubKeys[1]}))"
+				);
+			PolicyCompileLiftCheck(
+				$"or(pk({PubKeys[0]}),pk({PubKeys[1]}))",
+					$"or_b(c:pk({PubKeys[0]}),sc:pk({PubKeys[1]}))"
+				);
+			PolicyCompileLiftCheck(
+				$"thresh(2,pk({PubKeys[0]}),pk({PubKeys[1]}),pk({PubKeys[2]}))",
+					$"thresh_m(2,{PubKeys[0]},{PubKeys[1]},{PubKeys[2]})"
+				);
+			PolicyCompileLiftCheck($"or(1@and(pk({PubKeys[0]}),pk({PubKeys[1]})),127@pk({PubKeys[2]}))");
+		}
+
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void CompilerMisc()
+		{
+			var policy = ConcretePolicy<PubKey, uint160>.Parse($"and(older(10000),thresh(2,pk({PubKeys[0]}),pk({PubKeys[1]}),pk({PubKeys[2]})))");
+			var desc = policy.Compile();
+			var l = new List<Op>();
+			l.Add(Op.GetPushOp(2));
+			l.Add(Op.GetPushOp(PubKeys[0].ToBytes()));
+			l.Add(Op.GetPushOp(PubKeys[1].ToBytes()));
+			l.Add(Op.GetPushOp(PubKeys[2].ToBytes()));
+			l.Add(Op.GetPushOp(3));
+			l.Add(OpcodeType.OP_CHECKMULTISIGVERIFY);
+			l.Add(Op.GetPushOp(10000));
+			l.Add(OpcodeType.OP_CHECKSEQUENCEVERIFY);
+			var expectedStr = new Script(l);
+			Assert.Equal(expectedStr, desc.ToScript());
+
+			// Liquid policy
+			var pol = $"or(127@thresh(3,pk({PubKeys[0]}),pk({PubKeys[1]}),pk({PubKeys[2]}),pk({PubKeys[3]}),pk({PubKeys[4]})),1@and(older(10000),thresh(2,pk({PubKeys[5]}),pk({PubKeys[6]}),pk({PubKeys[7]}))))";
+			Console.WriteLine(pol);
+			var liquidPolicy = ConcretePolicy<PubKey, uint160>.Parse(pol);
+			var compiledLiquid = liquidPolicy.Compile();
+			var ms = Miniscript<PubKey, uint160>.Parse(
+				$"or_d(thresh_m(3,{PubKeys[0]},{PubKeys[1]},{PubKeys[2]},{PubKeys[3]},{PubKeys[4]})," +
+				$"and_v(v:thresh(2,c:pk_h({PubKeys[5].ToPubKeyHash()})," +
+				$"ac:pk_h({PubKeys[6].ToPubKeyHash()}),ac:pk_h({PubKeys[7].ToPubKeyHash()})),older(10000)))");
+			Assert.Equal(ms, compiledLiquid);
+		}
+
+
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void CompileValidTmp()
+		{
+			var sp = 0.66145833333333326;
+			var dp = 0.33854166666666669;
+			var policy = ConcretePolicy<PubKey, uint160>.Parse($"thresh(2,or(127@pk({PubKeys[2]}),1@pk({PubKeys[3]})),after(100),or(and(pk({PubKeys[4]}),after(200)),and(pk({PubKeys[0]}),sha256(66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925))))");
+			var compilation = Compiler<PubKey, uint160>.BestW(
+				new Dictionary<Tuple<ConcretePolicy<PubKey, uint160>, double, double?>,
+					IDictionary<CompilationKey, AstElemExt<PubKey, uint160>>>(),
+				policy,
+				sp,
+				dp
+			);
+			Assert.True(Property<Malleability, PubKey, uint160>.TypeCheck(compilation.Ms.Node, out var rm, new List<FragmentPropertyException>()) && rm.Dissat == Dissat.Unique);
+			Assert.True(Property<MiniscriptFragmentType, PubKey, uint160>.TypeCheck(compilation.Ms.Node, out var r, new List<FragmentPropertyException>()) && r.Malleability.Dissat == Dissat.Unique);
+			Assert.True(compilation.CompExtData.DissatCost.HasValue);
+		}
+
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void CompiledCostShouldBeSameWithRustBitcoin()
+		{
+			var threshPolicy = ConcretePolicy<PubKey, uint160>.Parse($"thresh(2,pk({PubKeys[0]}),pk({PubKeys[2]}))");
+			var compilation = Compiler<PubKey, uint160>.BestT(
+				new Dictionary<Tuple<ConcretePolicy<PubKey, uint160>, double, double?>,
+					IDictionary<CompilationKey, AstElemExt<PubKey, uint160>>>(),
+				threshPolicy,
+				1.0,
+				null
+			);
+			Assert.Equal(218, compilation.Cost1d(1.0, null));
+		}
+
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void CompileQ()
+		{
+			/*
+			var policy = ConcretePolicy<PubKey, uint160>.Parse($"or(1@and(pk({PubKeys[0]}),pk({PubKeys[1]})),127@pk({PubKeys[2]}))");
+			var compilation = Compiler<PubKey, uint160>.BestT(
+				new Dictionary<Tuple<ConcretePolicy<PubKey, uint160>, double, double?>,
+					IDictionary<CompilationKey, AstElemExt<PubKey, uint160>>>(),
+				policy,
+				1.0,
+				null
+			);
+			Assert.Equal(compilation.Cost1d(1.0, null), 88.0 + 74.109375);
+			Assert.Equal(policy.Lift(), compilation.Ms.Lift());
+			*/
+
+			var policy2 = ConcretePolicy<DummyKey, DummyKeyHash>.Parse("and(and(and(or(127@thresh(2,pk(),pk(),thresh(2,or(127@pk(),1@pk()),after(100),or(and(pk(),after(200)),and(pk(),sha256(66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925))),pk())),1@pk()),sha256(66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925)),or(127@pk(),1@after(300))),or(127@after(400),pk()))");
+			var compilation2 = Compiler<DummyKey, DummyKeyHash>.BestT(
+				new Dictionary<Tuple<ConcretePolicy<DummyKey, DummyKeyHash>, double, double?>,
+					IDictionary<CompilationKey, AstElemExt<DummyKey, DummyKeyHash>>>(),
+				policy2,
+				1.0,
+				null
+			);
+			Assert.Equal(compilation2.Cost1d(1.0, null), 437.0 + 299.4003295898438);
+			Assert.Equal(policy2.Lift(), compilation2.Ms.Lift());
+		}
+
+		[Fact]
+		[Trait("UnitTest","UnitTest")]
+		public void ShouldDeserializeScriptsIntoMiniscript()
+		{}
+	}
+}
diff --git a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
new file mode 100644
index 0000000000..bdbcf5679c
--- /dev/null
+++ b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
@@ -0,0 +1,50 @@
+using System;
+using System.Threading;
+using FsCheck;
+using Xunit;
+using FsCheck.Xunit;
+using NBitcoin.Scripting.Miniscript.Policy;
+using NBitcoin.Tests.Generators;
+
+namespace NBitcoin.Tests.PropertyTest
+{
+	public class MiniscriptPropertyTests
+	{
+		public MiniscriptPropertyTests()
+		{
+			Arb.Register<CryptoGenerator>();
+			Arb.Register<ConcretePolicyGenerator>();
+		}
+
+		[Property(MaxTest = 100)]
+		[Trait("UnitTest", "UnitTest")]
+		public void ShouldBidirectionallyConvertConcretePolicyToString(ConcretePolicy<PubKey, uint160> p)
+		{
+			var str = p.ToString();
+			var c = ConcretePolicy<PubKey, uint160>.Parse(str);
+			Assert.Equal(p, c);
+			Assert.Equal(str, c.ToString());
+			Assert.Equal(p.GetHashCode(), c.GetHashCode());
+		}
+
+		[Property(MaxTest = 400, Skip = "for now")]
+		[Trait("UnitTest", "UnitTest")]
+		public void ShouldCompileConcretePolicy(ConcretePolicy<PubKey, uint160> p)
+		{
+			var t = p.IsSafeNonMalleable();
+			var isSafe = t.Item1;
+			var IsNonMalleable = t.Item2;
+			if (isSafe && IsNonMalleable)
+			{
+				var ms = p.Compile();
+				Console.WriteLine($"Compiled {ms}");
+				var sc = ms.ToScript();
+				Console.WriteLine(sc);
+			}
+			else
+			{
+				Assert.Throws<CompilerException>(() => p.Compile());
+			}
+		}
+	}
+}
diff --git a/NBitcoin.Tests/TransactionBuilderTests.cs b/NBitcoin.Tests/TransactionBuilderTests.cs
new file mode 100644
index 0000000000..7411e260d6
--- /dev/null
+++ b/NBitcoin.Tests/TransactionBuilderTests.cs
@@ -0,0 +1,40 @@
+
+using Xunit;
+using NBitcoin;
+using System.Linq;
+
+namespace NBitcoin.Tests
+{
+	public class TransactionBuilderTests
+	{
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void TxBuilderDegradationTest()
+		{
+			var n = Network.RegTest;
+			var prevTx = n.CreateTransaction();
+			var amount = Money.Satoshis(50000);
+			var inputAmount = amount + Money.Satoshis(600000);
+			var bob = new Key();
+			prevTx.Outputs.Add(new TxOut(inputAmount, bob.PubKey.WitHash));
+			var coin = prevTx.Outputs.AsCoins().First();
+
+			var dummyChange = new Key();
+			var txb = n.CreateTransactionBuilder();
+			txb
+				.AddKeys(dummyChange)
+				.AddCoins(coin);
+
+			var dest = new Key().PubKey;
+			txb.Send(dest, Money.Satoshis(20000));
+
+			txb.SetChange(dummyChange);
+
+			var feeRate = new FeeRate(Money.Satoshis(1000));
+			var fees = txb.EstimateFees(feeRate);
+			txb.SendFees(fees);
+
+			txb.BuildTransaction(true);
+		}
+	}
+}
\ No newline at end of file
diff --git a/NBitcoin/KeyId.cs b/NBitcoin/KeyId.cs
index c69afb1502..e273530b72 100644
--- a/NBitcoin/KeyId.cs
+++ b/NBitcoin/KeyId.cs
@@ -1,6 +1,7 @@
 using NBitcoin.Crypto;
 using NBitcoin.DataEncoders;
 using System;
+using NBitcoin.Scripting.Miniscript;
 
 namespace NBitcoin
 {
@@ -122,6 +123,9 @@ public override BitcoinAddress GetAddress(Network network)
 		{
 			return network.NetworkStringParser.CreateP2PKH(this, network);
 		}
+
+		public uint160 ToHash160() =>
+			new uint160(this._DestBytes);
 	}
 	public class WitKeyId : TxDestination
 	{
diff --git a/NBitcoin/Policy/ITransactionPolicy.cs b/NBitcoin/Policy/ITransactionPolicy.cs
index 5afda1b3bb..ecc4af75e6 100644
--- a/NBitcoin/Policy/ITransactionPolicy.cs
+++ b/NBitcoin/Policy/ITransactionPolicy.cs
@@ -266,4 +266,4 @@ public interface ITransactionPolicy
 		/// <returns>Policy errors</returns>
 		TransactionPolicyError[] Check(Transaction transaction, ICoin[] spentCoins);
 	}
-}
\ No newline at end of file
+}
diff --git a/NBitcoin/PubKey.cs b/NBitcoin/PubKey.cs
index eff831705a..d33d3cf493 100644
--- a/NBitcoin/PubKey.cs
+++ b/NBitcoin/PubKey.cs
@@ -6,8 +6,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using System.Threading.Tasks;
 using NBitcoin.BouncyCastle.Math.EC;
+using NBitcoin.BouncyCastle.Utilities.Encoders;
+using NBitcoin.Scripting.Miniscript;
 
 namespace NBitcoin
 {
@@ -29,7 +30,7 @@ public enum ScriptPubKeyType
 		/// </summary>
 		SegwitP2SH
 	}
-	public class PubKey : IBitcoinSerializable, IDestination, IComparable<PubKey>, IEquatable<PubKey>
+	public class PubKey : IBitcoinSerializable, IDestination, IComparable<PubKey>, IEquatable<PubKey>, IMiniscriptKey<uint160>
 	{
 		/// <summary>
 		/// Create a new Public key from string
@@ -40,6 +41,8 @@ public PubKey(string hex)
 
 		}
 
+		public PubKey() {}
+
 		/// <summary>
 		/// Create a new Public key from byte array
 		/// </summary>
@@ -48,11 +51,29 @@ public PubKey(byte[] bytes)
 		{
 		}
 
+		public static bool TryParse(string hex, out PubKey result)
+		{
+			result = null;
+			if (hex == null) throw new ArgumentNullException(nameof(hex));
+			var v = Hex.Decode(hex);
+			if (!Check(v, true))
+				return false;
+			try
+			{
+				result = new PubKey(v);
+				return true;
+			}
+			catch
+			{
+				return false;
+			}
+		}
+
 		/// <summary>
 		/// Create a new Public key from byte array
 		/// </summary>
 		/// <param name="bytes">byte array</param>
-		/// <param name="unsafe">If false, make internal copy of bytes and does perform only a costly check for PubKey format. If true, the bytes array is used as is and only PubKey.Check is used for validating the format. </param>	 
+		/// <param name="unsafe">If false, make internal copy of bytes and does perform only a costly check for PubKey format. If true, the bytes array is used as is and only PubKey.Check is used for validating the format. </param>
 		public PubKey(byte[] bytes, bool @unsafe)
 		{
 			if (bytes == null)
@@ -238,6 +259,9 @@ public string ToHex()
 			return Encoders.Hex.EncodeData(vch);
 		}
 
+		public bool Equals(IMiniscriptKey<uint160> other)
+			=> Equals(other as PubKey);
+
 		#region IBitcoinSerializable Members
 
 		public void ReadWrite(BitcoinStream stream)
@@ -555,5 +579,12 @@ public BitcoinWitPubKeyAddress GetSegwitAddress(Network network)
 		}
 
 		#endregion
+
+		public uint160 ToPubKeyHash()
+			=> new uint160(Hash._DestBytes);
+		public PubKey ToPublicKey() => this;
+
+		public int SerializedLength() =>
+			this.ToBytes().Length;
 	}
 }
diff --git a/NBitcoin/Scripting/Descriptor/CreateDescriptor.cs b/NBitcoin/Scripting/Descriptor/CreateDescriptor.cs
new file mode 100644
index 0000000000..52fefe34b5
--- /dev/null
+++ b/NBitcoin/Scripting/Descriptor/CreateDescriptor.cs
@@ -0,0 +1,7 @@
+namespace NBitcoin.Scripting.Descriptor
+{
+	public class CreateDescriptor
+	{
+
+	}
+}
diff --git a/NBitcoin/Scripting/Descriptor/DescriptorError.cs b/NBitcoin/Scripting/Descriptor/DescriptorError.cs
new file mode 100644
index 0000000000..303f480d08
--- /dev/null
+++ b/NBitcoin/Scripting/Descriptor/DescriptorError.cs
@@ -0,0 +1,7 @@
+namespace NBitcoin.Scripting.Descriptor
+{
+	public class DescriptorError
+	{
+		
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
new file mode 100644
index 0000000000..63d90bfc58
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -0,0 +1,1438 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using NBitcoin.Scripting.Miniscript.Types;
+using NBitcoin.Scripting.Parser;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	internal class NonTerm : IEquatable<NonTerm>
+	{
+		#region Subtype definitions
+
+		internal static class Tags
+		{
+			public const int Expression = 0;
+			public const int MaybeSwap = 1;
+			public const int MaybeAndV = 2;
+			public const int Alt = 3;
+			public const int Check = 4;
+			public const int DupIf = 5;
+			public const int Verify = 6;
+			public const int NonZero = 7;
+			public const int ZeroNotEqual = 8;
+			public const int AndV = 9;
+			public const int AndB = 10;
+			public const int Tern = 11;
+			public const int OrB = 12;
+			public const int OrD = 13;
+			public const int OrC = 14;
+			public const int ThreshW = 15;
+			public const int ThreshE = 16;
+			/// <summary>
+			/// Could be or_d, or_c, or_i, d, n
+			/// </summary>
+			public const int EndIf = 17;
+
+			public const int EndIfNotIf = 18;
+			public const int EndIfElse = 19;
+		}
+
+		private int Tag;
+		private NonTerm(int tag) => Tag = tag;
+		public static NonTerm Expression { get; } = new NonTerm(Tags.Expression);
+		public static NonTerm MaybeSwap { get; } = new NonTerm(Tags.MaybeSwap);
+		public static NonTerm MaybeAndV { get; } = new NonTerm(Tags.MaybeAndV);
+		public static NonTerm Alt { get; } = new NonTerm(Tags.Alt);
+		public static NonTerm Check  { get; } = new NonTerm(Tags.Check);
+		public static NonTerm DupIf { get; } = new NonTerm(Tags.DupIf);
+		public static NonTerm Verify { get; } = new NonTerm(Tags.Verify);
+		public static NonTerm NonZero { get; } = new NonTerm(Tags.NonZero);
+		public static NonTerm ZeroNotEqual { get; } = new NonTerm(Tags.ZeroNotEqual);
+		public static NonTerm AndV { get; } = new NonTerm(Tags.AndV);
+		public static NonTerm AndB { get; } = new NonTerm(Tags.AndB);
+		public static NonTerm Tern { get; } = new NonTerm(Tags.Tern);
+		public static NonTerm OrB { get; } = new NonTerm(Tags.OrB);
+		public static NonTerm OrD { get; } = new NonTerm(Tags.OrD);
+		public static NonTerm OrC { get; } = new NonTerm(Tags.OrC);
+		public static NonTerm EndIf { get; } = new NonTerm(Tags.EndIf);
+		public static NonTerm EndIfNotIf { get; } = new NonTerm(Tags.EndIfNotIf);
+		public static NonTerm EndIfElse { get; } = new NonTerm(Tags.EndIfElse);
+
+		public class ThreshW : NonTerm
+		{
+			public ulong K;
+			public ulong N;
+
+			public ThreshW(ulong k, ulong n) : base(Tags.ThreshW)
+			{
+				N = n;
+				K = k;
+			}
+		}
+
+		public class ThreshE : NonTerm
+		{
+			public ulong K;
+			public ulong N;
+
+			public ThreshE(ulong k, ulong n) : base(Tags.ThreshW)
+			{
+				N = n;
+				K = k;
+			}
+		}
+		#endregion
+
+		#region Equatable members
+		public bool Equals(NonTerm other)
+		{
+			throw new NotImplementedException("");
+		}
+		#endregion
+	}
+
+	[DebuggerDisplay("{" + nameof(ToDebugString) + "()}")]
+	public partial class Terminal<TPk, TPKh> : IEquatable<Terminal<TPk, TPKh>>
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
+	{
+		private static DataEncoders.HexEncoder Hex = new DataEncoders.HexEncoder();
+		# region Subtype definitions
+		internal static class Tags
+		{
+			/// <summary>
+			/// `1`
+			/// </summary>
+			public const int True = 0;
+			/// <summary>
+			/// `0`
+			/// </summary>
+			public const int False = 1;
+			/// <summary>
+			/// `<key>`
+			/// </summary>
+			public const int Pk = 2;
+			/// <summary>
+			/// `DUP HASH160 <keyhash> EQUALVERIFY`
+			/// </summary>
+			public const int PkH = 3;
+			/// <summary>
+			/// relative timelock
+			/// `n CHECKSEQUENCEVERIFY`
+			/// </summary>
+			public const int After = 4;
+			/// <summary>
+			/// Absolute timelock
+			/// `n CHECKLOCKTIMEVERIFY`
+			/// </summary>
+			public const int Older = 5;
+			/// <summary>
+			/// `SIZE 32 EQUALVERIFY SHA256 <hash> EQUAL`
+			/// </summary>
+			public const int Sha256 = 6;
+			/// <summary>
+			/// `SIZE 32 EQUALVERIFY HASH256 <hash> EQUAL`
+			/// </summary>
+			public const int Hash256 = 7;
+			/// <summary>
+			/// `SIZE 32 EQUALVERIFY RIEPMD160 <hash> EQUAL`
+			/// </summary>
+			public const int Ripemd160 = 8;
+			/// <summary>
+			/// `SIZE 32 EQUALVERIFY HASH160 <hash> EQUAL`
+			/// </summary>
+			public const int Hash160 = 9;
+			// ------ wrappers ----
+			/// <summary>
+			/// `TOALTSTACK [E] FROMALTSTACK`
+			/// </summary>
+			public const int Alt = 10;
+			public const int Swap = 11;
+			public const int Check = 12;
+			public const int DupIf = 13;
+			public const int Verify = 14;
+			public const int NonZero = 15;
+			public const int ZeroNotEqual = 16;
+			// --------------------
+			public const int AndV = 17;
+			public const int AndB = 18;
+			public const int AndOr = 19;
+			public const int OrB = 20;
+			public const int OrD = 21;
+			public const int OrC = 22;
+			public const int OrI = 23;
+			public const int Thresh = 24;
+			public const int ThreshM = 25;
+		}
+
+		internal int Tag;
+
+		private Terminal(int tag) => Tag = tag;
+		public static Terminal<TPk, TPKh> True { get; } = new Terminal<TPk, TPKh>(Tags.True);
+		public static Terminal<TPk, TPKh> False { get; } = new Terminal<TPk, TPKh>(Tags.False);
+
+		internal class Pk : Terminal<TPk, TPKh>
+		{
+			readonly public TPk Item;
+			public Pk(TPk pk) : base(Tags.Pk) => Item = pk;
+		}
+
+		internal class PkH : Terminal<TPk, TPKh>
+		{
+			readonly public TPKh Item;
+			public PkH(TPKh item) : base(Tags.PkH) => Item = item;
+		}
+
+		internal class After : Terminal<TPk, TPKh>
+		{
+			readonly public uint Item;
+			public After(uint item) : base(Tags.After) => Item = item;
+		}
+
+		internal class Older : Terminal<TPk, TPKh>
+		{
+			readonly public uint Item;
+			public Older(uint item) : base(Tags.Older) => Item = item;
+		}
+
+		internal class Sha256 : Terminal<TPk, TPKh>
+		{
+			readonly public uint256 Item;
+			public Sha256(uint256 item) : base(Tags.Sha256) => Item = item;
+		}
+		internal class Hash256 : Terminal<TPk, TPKh>
+		{
+			readonly public uint256 Item;
+			public Hash256(uint256 item) : base(Tags.Hash256) => Item = item;
+		}
+
+		internal class Ripemd160 : Terminal<TPk, TPKh>
+		{
+			readonly public uint160 Item;
+			public Ripemd160(uint160 item) : base(Tags.Ripemd160) => Item = item;
+		}
+
+		internal class Hash160 : Terminal<TPk, TPKh>
+		{
+			readonly public uint160 Item;
+			public Hash160(uint160 item) : base(Tags.Hash160) => Item = item;
+		}
+
+		internal class Alt : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item;
+			public Alt(Miniscript<TPk, TPKh> item) : base(Tags.Alt) => Item = item;
+		}
+
+		internal class Swap : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item;
+			public Swap(Miniscript<TPk, TPKh> item): base(Tags.Swap) => Item = item;
+		}
+
+		internal class Check : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item;
+			public Check(Miniscript<TPk, TPKh> item): base(Tags.Check) => Item = item;
+		}
+		internal class DupIf : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item;
+			public DupIf (Miniscript<TPk, TPKh> item): base(Tags.DupIf ) => Item = item;
+		}
+		internal class Verify : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item;
+			public Verify(Miniscript<TPk, TPKh> item): base(Tags.Verify) => Item = item;
+		}
+		internal class NonZero : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item;
+			public NonZero(Miniscript<TPk, TPKh> item): base(Tags.NonZero) => Item = item;
+		}
+		internal class ZeroNotEqual : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item;
+			public ZeroNotEqual(Miniscript<TPk, TPKh> item): base(Tags.ZeroNotEqual) => Item = item;
+		}
+		internal class AndV : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item1;
+			readonly public Miniscript<TPk, TPKh> Item2;
+			public AndV(Miniscript<TPk, TPKh> item1,Miniscript<TPk, TPKh> item2): base(Tags.AndV)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+		internal class AndB : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item1;
+			readonly public Miniscript<TPk, TPKh> Item2;
+			public AndB(Miniscript<TPk, TPKh> item, Miniscript<TPk, TPKh> item2): base(Tags.AndB)
+			{
+				Item1 = item;
+				Item2 = item2;
+			}
+		}
+		internal class AndOr : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item1;
+			readonly public Miniscript<TPk, TPKh> Item2;
+			readonly public Miniscript<TPk, TPKh> Item3;
+
+			public AndOr(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2, Miniscript<TPk, TPKh> item3) : base(Tags.AndOr)
+			{
+				Item1 = item1;
+				Item2 = item2;
+				Item3 = item3;
+			}
+		}
+		internal class OrB : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item1;
+			readonly public Miniscript<TPk, TPKh> Item2;
+			public OrB(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2): base(Tags.OrB)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+		internal class OrD : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item1;
+			readonly public Miniscript<TPk, TPKh> Item2;
+			public OrD(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2): base(Tags.OrD)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+
+		internal class OrC : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item1;
+			readonly public Miniscript<TPk, TPKh> Item2;
+			public OrC(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2): base(Tags.OrC)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+
+		internal class OrI : Terminal<TPk, TPKh>
+		{
+			readonly public Miniscript<TPk, TPKh> Item1;
+			readonly public Miniscript<TPk, TPKh> Item2;
+			public OrI(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2): base(Tags.OrI)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+		internal class Thresh : Terminal<TPk, TPKh>
+		{
+			readonly public uint Item1;
+			readonly public Miniscript<TPk, TPKh>[] Item2;
+			public Thresh(uint item1, Miniscript<TPk, TPKh>[] item2): base(Tags.Thresh)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+		internal class ThreshM : Terminal<TPk, TPKh>
+		{
+			readonly public uint Item1;
+			readonly public TPk[] Item2;
+			public ThreshM(uint item1, TPk[] item2): base(Tags.ThreshM)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+
+		public static Terminal<TPk, TPKh> NewTrue() => Terminal<TPk, TPKh>.True;
+		public static Terminal<TPk, TPKh> NewFalse() => Terminal<TPk, TPKh>.False;
+		public static Terminal<TPk, TPKh> NewPk(TPk item)
+		{
+			if (item is null)
+				throw new ArgumentNullException(nameof(item));
+
+			return new Pk(item);
+		}
+
+		public static Terminal<TPk, TPKh> NewPkH(TPKh item) => new PkH(item);
+		public static Terminal<TPk, TPKh> NewAfter(uint item) => new After(item);
+		public static Terminal<TPk, TPKh> NewOlder(uint item) => new Older(item);
+		public static Terminal<TPk, TPKh> NewSha256(uint256 item)
+			=>  new Sha256(item);
+		public static Terminal<TPk, TPKh> NewHash256(uint256 item)
+			=> new Hash256(item);
+		public static Terminal<TPk, TPKh> NewRipemd160(uint160 item)
+			=> new Ripemd160(item);
+		public static Terminal<TPk, TPKh> NewHash160(uint160 item)
+			=> new Hash160(item);
+		public static Terminal<TPk, TPKh> NewAlt(Miniscript<TPk, TPKh> item) => new Terminal<TPk, TPKh>.Alt(item);
+		public static Terminal<TPk, TPKh> NewSwap(Miniscript<TPk, TPKh> item) => new Terminal<TPk, TPKh>.Swap(item);
+		public static Terminal<TPk, TPKh> NewCheck(Miniscript<TPk, TPKh> item)
+		{
+			if (item is null)
+				throw new ArgumentNullException(nameof(item));
+
+			return new Check(item);
+		}
+
+		public static Terminal<TPk, TPKh> NewDupIf(Miniscript<TPk, TPKh> item) => new DupIf(item);
+		public static Terminal<TPk, TPKh> NewVerify(Miniscript<TPk, TPKh> item) => new Verify(item);
+		public static Terminal<TPk, TPKh> NewNonZero(Miniscript<TPk, TPKh> item) => new NonZero(item);
+		public static Terminal<TPk, TPKh> NewZeroNotEqual(Miniscript<TPk, TPKh> item) => new ZeroNotEqual(item);
+
+		public static Terminal<TPk, TPKh> NewAndV(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2)
+			=> new AndV(item1, item2);
+
+		public static Terminal<TPk, TPKh> NewAndB(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2)
+			=> new AndB(item1, item2);
+
+		public static Terminal<TPk, TPKh> NewAndOr(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2, Miniscript<TPk, TPKh> item3)
+			=> new AndOr(item1, item2, item3);
+
+		public static Terminal<TPk, TPKh> NewOrB(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2)
+		{
+			if (item1 is null)
+				throw new ArgumentNullException(nameof(item1));
+
+			if (item2 is null)
+				throw new ArgumentNullException(nameof(item2));
+
+			return new OrB(item1, item2);
+		}
+
+		public static Terminal<TPk, TPKh> NewOrD(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2)
+			=> new OrD(item1, item2);
+		public static Terminal<TPk, TPKh> NewOrC(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2)
+			=> new OrC(item1, item2);
+		public static Terminal<TPk, TPKh> NewOrI(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2)
+			=> new OrI(item1, item2);
+
+		public static Terminal<TPk, TPKh> NewThresh(uint item1, IEnumerable<Miniscript<TPk, TPKh>> item2)
+			=> new Thresh(item1, item2.ToArray());
+		public static Terminal<TPk, TPKh> NewThreshM(uint item1, IEnumerable<TPk> item2)
+			=> new ThreshM(item1, item2.ToArray());
+		#endregion
+
+		#region Equatable members
+		public bool Equals(Terminal<TPk, TPKh> other)
+			=> this.ToScript().Equals(other.ToScript());
+
+		public override int GetHashCode()
+			=> this.ToScript().GetHashCode();
+		#endregion
+
+		public Script ToScript() =>
+			new Script(this.ToOpList());
+		private List<Op> ToOpList()
+		{
+			var l = new List<Op>();
+			switch (this.Tag)
+			{
+				case Tags.True:
+					l.Add(OpcodeType.OP_TRUE);
+					return l;
+				case Tags.False:
+					l.Add(OpcodeType.OP_FALSE);
+					return l;
+			}
+			switch (this)
+			{
+				case Pk self:
+					l.Add(Op.GetPushOp(self.Item.ToPublicKey().ToBytes()));
+					return l;
+				case PkH self:
+					l.Add(OpcodeType.OP_DUP);
+					l.Add(OpcodeType.OP_HASH160);
+					l.Add(Op.GetPushOp(self.Item.ToHash160().ToBytes()));
+					l.Add(OpcodeType.OP_EQUALVERIFY);
+					return l;
+				case After self:
+					l.Add(Op.GetPushOp(self.Item));
+					l.Add(OpcodeType.OP_CHECKLOCKTIMEVERIFY);
+					return l;
+				case Older self:
+					l.Add(Op.GetPushOp(self.Item));
+					l.Add(OpcodeType.OP_CHECKSEQUENCEVERIFY);
+					return l;
+				case Sha256 self:
+					l.Add(OpcodeType.OP_SIZE);
+					l.Add(Op.GetPushOp(32));
+					l.Add(OpcodeType.OP_EQUALVERIFY);
+					l.Add(OpcodeType.OP_SHA256);
+					l.Add(Op.GetPushOp(self.Item.ToBytes()));
+					l.Add(OpcodeType.OP_EQUAL);
+					return l;
+				case Hash256 self:
+					l.Add(OpcodeType.OP_SIZE);
+					l.Add(Op.GetPushOp(32));
+					l.Add(OpcodeType.OP_EQUALVERIFY);
+					l.Add(OpcodeType.OP_HASH256);
+					l.Add(Op.GetPushOp(self.Item.ToBytes()));
+					l.Add(OpcodeType.OP_EQUAL);
+					return l;
+				case Ripemd160 self:
+					l.Add(OpcodeType.OP_SIZE);
+					l.Add(Op.GetPushOp(32));
+					l.Add(OpcodeType.OP_EQUALVERIFY);
+					l.Add(OpcodeType.OP_RIPEMD160);
+					l.Add(Op.GetPushOp(self.Item.ToBytes()));
+					l.Add(OpcodeType.OP_EQUAL);
+					return l;
+				case Hash160 self:
+					l.Add(OpcodeType.OP_SIZE);
+					l.Add(Op.GetPushOp(32));
+					l.Add(OpcodeType.OP_EQUALVERIFY);
+					l.Add(OpcodeType.OP_HASH160);
+					l.Add(Op.GetPushOp(self.Item.ToBytes()));
+					l.Add(OpcodeType.OP_EQUAL);
+					return l;
+				case Alt self:
+					l.Add(OpcodeType.OP_TOALTSTACK);
+					l.AddRange(self.Item.Node.ToOpList());
+					l.Add(OpcodeType.OP_FROMALTSTACK);
+					return l;
+				case Swap self:
+					l.Add(OpcodeType.OP_SWAP);
+					l.AddRange(self.Item.Node.ToOpList());
+					return l;
+				case Check self:
+					l.AddRange(self.Item.Node.ToOpList());
+					l.Add(OpcodeType.OP_CHECKSIG);
+					return l;
+				case DupIf self:
+					l.Add(OpcodeType.OP_DUP);
+					l.Add(OpcodeType.OP_IF);
+					l.AddRange(self.Item.Node.ToOpList());
+					l.Add(OpcodeType.OP_ENDIF);
+					return l;
+				case Verify self:
+					l.AddRange(self.Item.Node.ToOpList());
+					l.PushVerify();
+					return l;
+				case NonZero self:
+					l.Add(OpcodeType.OP_SIZE);
+					l.Add(OpcodeType.OP_0NOTEQUAL);
+					l.Add(OpcodeType.OP_IF);
+					l.AddRange((self.Item.Node.ToOpList()));
+					l.Add(OpcodeType.OP_ENDIF);
+					return l;
+				case ZeroNotEqual self:
+					l.AddRange(self.Item.Node.ToOpList());
+					l.Add(OpcodeType.OP_0NOTEQUAL);
+					return l;
+				case AndV self:
+					l.AddRange(self.Item1.Node.ToOpList());
+					l.AddRange(self.Item2.Node.ToOpList());
+					return l;
+				case AndB self:
+					l.AddRange(self.Item1.Node.ToOpList());
+					l.AddRange(self.Item2.Node.ToOpList());
+					l.Add(OpcodeType.OP_BOOLAND);
+					return l;
+				case AndOr self:
+					l.AddRange(self.Item1.Node.ToOpList());
+					l.Add(OpcodeType.OP_NOTIF);
+					l.AddRange(self.Item3.Node.ToOpList());
+					l.Add(OpcodeType.OP_ELSE);
+					l.AddRange(self.Item2.Node.ToOpList());
+					l.Add(OpcodeType.OP_ENDIF);
+					return l;
+				case OrB self:
+					l.AddRange(self.Item1.Node.ToOpList());
+					l.AddRange(self.Item2.Node.ToOpList());
+					l.Add(OpcodeType.OP_BOOLOR);
+					return l;
+				case OrD self:
+					l.AddRange(self.Item1.Node.ToOpList());
+					l.Add(OpcodeType.OP_IFDUP);
+					l.Add(OpcodeType.OP_NOTIF);
+					l.AddRange(self.Item2.Node.ToOpList());
+					l.Add(OpcodeType.OP_ENDIF);
+					return l;
+				case OrC self:
+					l.AddRange(self.Item1.Node.ToOpList());
+					l.Add(OpcodeType.OP_NOTIF);
+					l.AddRange(self.Item2.Node.ToOpList());
+					l.Add(OpcodeType.OP_ENDIF);
+					return l;
+				case OrI self:
+					l.Add(OpcodeType.OP_IF);
+					l.AddRange(self.Item1.Node.ToOpList());
+					l.Add(OpcodeType.OP_ELSE);
+					l.AddRange(self.Item2.Node.ToOpList());
+					l.Add(OpcodeType.OP_ENDIF);
+					return l;
+				case Thresh self:
+					l.AddRange(self.Item2[0].Node.ToOpList());
+					foreach (var sub in self.Item2.Skip(1))
+					{
+						l.AddRange(sub.Node.ToOpList());
+						l.Add(OpcodeType.OP_ADD);
+					}
+					l.Add(Op.GetPushOp((long)self.Item1));
+					l.Add(OpcodeType.OP_EQUAL);
+					return l;
+				case ThreshM self:
+					l.Add(Op.GetPushOp((long)self.Item1));
+					foreach (var sub in self.Item2)
+					{
+						l.Add(Op.GetPushOp(sub.ToPublicKey().ToBytes()));
+					}
+					l.Add(Op.GetPushOp(self.Item2.Length));
+					l.Add(OpcodeType.OP_CHECKMULTISIG);
+					return l;
+			}
+			throw new Exception(($"Unreachable! {this}"));
+		}
+
+		public int ScriptSize()
+		{
+			switch (this.Tag)
+			{
+				case Tags.True:
+					return 1;
+				case Tags.False:
+					return 1;
+			}
+
+			switch (this)
+			{
+				case Pk self:
+					return self.Item.SerializedLength();
+				case PkH _:
+					return 24;
+				case After self:
+					return Utils.ScriptNumSize(self.Item) + 1;
+				case Older self:
+					return Utils.ScriptNumSize(self.Item) + 1;
+				case Sha256 _:
+					return 33 + 6;
+				case Hash256 _:
+					return 33 + 6;
+				case Ripemd160 _:
+					return 21 + 6;
+				case Hash160 _:
+					return 21 + 6;
+				case Alt self:
+					return self.Item.Node.ScriptSize() + 2;
+				case Swap self:
+					return self.Item.Node.ScriptSize() + 1;
+				case Check self:
+					return self.Item.Node.ScriptSize() + 1;
+				case DupIf self:
+					return self.Item.Node.ScriptSize() + 3;
+				case Verify self:
+					return self.Item.Node.ScriptSize() + (self.Item.Ext.HasVerifyForm ? 0 : 1);
+				case NonZero self:
+					return self.Item.Node.ScriptSize() + 4;
+				case ZeroNotEqual self:
+					return self.Item.Node.ScriptSize() + 1;
+				case AndV self:
+					return self.Item1.Node.ScriptSize() + self.Item2.Node.ScriptSize();
+				case AndB self:
+					return self.Item1.Node.ScriptSize() + self.Item2.Node.ScriptSize() + 1;
+				case AndOr self:
+					return
+						self.Item1.Node.ScriptSize() +
+						self.Item2.Node.ScriptSize() +
+						self.Item3.Node.ScriptSize() + 3;
+				case OrB self:
+					return
+						self.Item1.Node.ScriptSize() + self.Item2.Node.ScriptSize() + 1;
+				case OrD self:
+					return
+						self.Item1.Node.ScriptSize() + self.Item2.Node.ScriptSize() + 3;
+				case OrC self:
+					return
+						self.Item1.Node.ScriptSize() + self.Item2.Node.ScriptSize() + 2;
+				case OrI self:
+					return
+						self.Item1.Node.ScriptSize() + self.Item2.Node.ScriptSize() + 3;
+				case Thresh self:
+					Debug.Assert(self.Item2.Length != 0);
+					return
+						Utils.ScriptNumSize(self.Item1) + // k
+						1 + // EQUAL
+						self.Item2.Select(s => s.Node.ScriptSize()).Sum() +
+						self.Item2.Length // ADD
+                        - 1; // no ADD on first element
+				case ThreshM self:
+					return
+						Utils.ScriptNumSize(self.Item1) +
+						1 +
+						Utils.ScriptNumSize(self.Item2.Length) +
+						self.Item2.Select(x => x.SerializedLength()).Sum();
+			}
+
+			throw new Exception("Unreachable!");
+		}
+
+		public int? MaxDissatisfactionWitnessElements()
+		{
+			switch (this.Tag)
+			{
+				case (Tags.False):
+					return 0;
+			}
+			switch (this)
+			{
+				case Pk _:
+					return 1;
+				case PkH _:
+					return 2;
+				case Alt self:
+					return self.Item.Node.MaxDissatisfactionWitnessElements();
+				case Swap self:
+					return self.Item.Node.MaxDissatisfactionWitnessElements();
+				case Check self:
+					return self.Item.Node.MaxDissatisfactionWitnessElements();
+				case DupIf _:
+					return 1;
+				case NonZero _:
+					return 1;
+				case AndB self:
+					return
+						self.Item1.Node.MaxDissatisfactionWitnessElements() +
+						self.Item2.Node.MaxDissatisfactionWitnessElements();
+				case AndOr self:
+					return
+						self.Item1.Node.MaxDissatisfactionWitnessElements() +
+						self.Item3.Node.MaxDissatisfactionWitnessElements();
+				case OrB self:
+					return
+						self.Item1.Node.MaxDissatisfactionWitnessElements() +
+						self.Item2.Node.MaxDissatisfactionWitnessElements();
+				case OrI self:
+					var l = self.Item1.Node.MaxDissatisfactionWitnessElements();
+					var r = self.Item2.Node.MaxDissatisfactionWitnessElements();
+					if (!l.HasValue && r.HasValue)
+						return 1 + r.Value;
+					else if (l.HasValue && !r.HasValue)
+						return 1 + l.Value;
+					else if (!(l.HasValue) && (!r.HasValue))
+						return null;
+					throw new Exception($"tried to dissatisfy or_i with both branches being dissatisfiable");
+				case Thresh self:
+					var sum = 0;
+					foreach (var sub in self.Item2)
+					{
+						var s = sub.Node.MaxDissatisfactionWitnessElements();
+						if (s.HasValue)
+							sum += s.Value;
+						else
+							return null;
+					}
+					return sum;
+				case ThreshM self:
+					return 1 + (int)self.Item1;
+			}
+
+			return null;
+		}
+
+		public int? MaxDissatisfactionSize(int oneCost)
+		{
+			switch (this.Tag)
+			{
+				case (Tags.False):
+					return 0;
+			}
+
+			switch (this)
+			{
+				case Pk _:
+					return 1;
+				case PkH _:
+					return 35;
+				case Alt self:
+					return self.Item.Node.MaxDissatisfactionSize(oneCost);
+				case Swap self:
+					return self.Item.Node.MaxDissatisfactionSize(oneCost);
+				case Check self:
+					return self.Item.Node.MaxDissatisfactionSize(oneCost);
+				case DupIf _:
+					return 1;
+				case NonZero _:
+					return 1;
+				case AndB self:
+					return
+						self.Item1.Node.MaxDissatisfactionSize(oneCost) +
+						self.Item2.Node.MaxDissatisfactionSize(oneCost);
+				case AndOr self:
+					return
+						self.Item1.Node.MaxDissatisfactionSize(oneCost) +
+						self.Item3.Node.MaxDissatisfactionSize(oneCost);
+				case OrB self:
+					return
+						self.Item1.Node.MaxDissatisfactionSize(oneCost) +
+						self.Item2.Node.MaxDissatisfactionSize(oneCost);
+				case OrD self:
+					return
+						self.Item1.Node.MaxDissatisfactionSize(oneCost) +
+						self.Item2.Node.MaxDissatisfactionSize(oneCost);
+				case OrI self:
+					var l = self.Item1.Node.MaxDissatisfactionSize(oneCost);
+					var r = self.Item2.Node.MaxDissatisfactionSize(oneCost);
+					if (!l.HasValue && r.HasValue)
+						return 1 + r.Value;
+					else if (l.HasValue && !r.HasValue)
+						return oneCost + l.Value;
+					else if (!(l.HasValue) && (!r.HasValue))
+						return null;
+					throw new Exception($"tried to dissatisfy or_i with both branches being dissatisfiable");
+
+				case Thresh self:
+					var sum = 0;
+					foreach (var sub in self.Item2)
+					{
+						var s = sub.Node.MaxDissatisfactionSize(oneCost);
+						if (s.HasValue)
+							sum += s.Value;
+						else
+							return null;
+					}
+					return sum;
+				case ThreshM self:
+					return 1 + (int)self.Item1;
+			}
+
+			return null;
+		}
+
+		public int MaxSatisfactionWitnessElements()
+		{
+			switch (this.Tag)
+			{
+				case Tags.True: return 0;
+				case Tags.False: return 0;
+			}
+
+			switch (this)
+			{
+				case Pk _:
+					return 1;
+				case PkH _: return 2;
+				case After _: return 0;
+				case Older _: return 0;
+				case Sha256 _: return 1;
+				case Hash256 _: return 1;
+				case Ripemd160 _: return 1;
+				case Hash160 _: return 1;
+				case Alt self:
+					return self.Item.Node.MaxSatisfactionWitnessElements();
+				case Swap self:
+					return self.Item.Node.MaxSatisfactionWitnessElements();
+				case Check self:
+					return self.Item.Node.MaxSatisfactionWitnessElements();
+				case DupIf self:
+					return 1 + self.Item.Node.MaxSatisfactionWitnessElements();
+				case Verify self:
+					return self.Item.Node.MaxSatisfactionWitnessElements();
+				case NonZero self:
+					return self.Item.Node.MaxSatisfactionWitnessElements();
+				case ZeroNotEqual self:
+					return self.Item.Node.MaxSatisfactionWitnessElements();
+				case AndV self:
+					return
+						self.Item1.Node.MaxSatisfactionWitnessElements() +
+						self.Item2.Node.MaxSatisfactionWitnessElements();
+				case AndB self:
+					return
+						self.Item1.Node.MaxSatisfactionWitnessElements() +
+						self.Item2.Node.MaxSatisfactionWitnessElements();
+				case AndOr self:
+					var aSat = self.Item1.Node.MaxSatisfactionWitnessElements();
+					var aDissat = self.Item1.Node.MaxDissatisfactionWitnessElements();
+					return
+						Math.Max(
+							(aSat + self.Item3.Node.MaxSatisfactionWitnessElements()),
+							 aDissat.Value + self.Item2.Node.MaxSatisfactionWitnessElements());
+				case OrB self:
+					return
+						Math.Max(
+							(self.Item1.Node.MaxSatisfactionWitnessElements() +
+							 self.Item2.Node.MaxDissatisfactionWitnessElements().Value),
+							(self.Item1.Node.MaxDissatisfactionWitnessElements().Value +
+							 self.Item2.Node.MaxSatisfactionWitnessElements())
+						);
+				case OrD self:
+					return
+						Math.Max(
+							self.Item1.Node.MaxSatisfactionWitnessElements(),
+							self.Item1.Node.MaxDissatisfactionWitnessElements().Value + self.Item2.Node.MaxSatisfactionWitnessElements()
+							);
+				case OrC self:
+					return
+						Math.Max(
+							self.Item1.Node.MaxSatisfactionWitnessElements(),
+							self.Item1.Node.MaxDissatisfactionWitnessElements().Value + self.Item2.Node.MaxSatisfactionWitnessElements()
+							);
+				case OrI self:
+					return
+						1 + Math.Max(
+							self.Item1.Node.MaxSatisfactionWitnessElements(),
+							self.Item2.Node.MaxSatisfactionWitnessElements());
+				case Thresh self:
+					return
+						self.Item2
+							.Select(sub =>
+								Tuple.Create(sub.Node.MaxSatisfactionWitnessElements(),
+									sub.Node.MaxDissatisfactionWitnessElements().Value)
+							)
+							.OrderBy(t => t.Item1 - t.Item2)
+							.Reverse()
+							.Select((t, i) => i < self.Item1 ? t.Item1 : t.Item2)
+							.Sum();
+						;
+				case ThreshM self: return 1 + (int)self.Item1;
+			}
+
+			throw new Exception("Unreachable!");
+		}
+
+		/// <summary>
+		/// Maximum size, in bytes, of a satisfying witness.
+		/// </summary>
+		/// <returns></returns>
+		public int MaxSatisfactionSize(int oneCost)
+		{
+			switch (Tag)
+			{
+				case Tags.True: return 0;
+				case Tags.False: return 0;
+			}
+
+			switch (this)
+			{
+				case Pk _: return 73;
+				case PkH _: return 34 + 73;
+				case After _: return 0;
+				case Older _: return 0;
+				case Sha256 _: return 33;
+				case Hash256 _: return 33;
+				case Ripemd160 _: return 33;
+				case Hash160 _: return 33;
+				case Alt self: return self.Item.Node.MaxSatisfactionSize(oneCost);
+				case Swap self: return self.Item.Node.MaxSatisfactionSize(oneCost);
+				case Check self: return self.Item.Node.MaxSatisfactionSize(oneCost);
+				case DupIf self: return oneCost + self.Item.Node.MaxSatisfactionSize(oneCost);
+				case Verify self: return self.Item.Node.MaxSatisfactionSize(oneCost);
+				case NonZero self: return self.Item.Node.MaxSatisfactionSize(oneCost);
+				case ZeroNotEqual self: return self.Item.Node.MaxSatisfactionSize(oneCost);
+				case AndV self:
+					return self.Item1.Node.MaxSatisfactionSize(oneCost) + self.Item2.Node.MaxSatisfactionSize(oneCost);
+				case AndB self:
+					return self.Item1.Node.MaxSatisfactionSize(oneCost) + self.Item2.Node.MaxSatisfactionSize(oneCost);
+				case AndOr self:
+					return
+						Math.Max(
+							self.Item1.Node.MaxSatisfactionSize(oneCost) + self.Item3.Node.MaxSatisfactionSize(oneCost),
+							self.Item1.Node.MaxDissatisfactionSize(oneCost).Value +
+							self.Item2.Node.MaxSatisfactionSize(oneCost)
+						);
+				case OrB self:
+					return
+						Math.Max(
+							self.Item1.Node.MaxSatisfactionSize(oneCost) +
+							self.Item2.Node.MaxDissatisfactionSize(oneCost).Value,
+							self.Item1.Node.MaxDissatisfactionSize(oneCost).Value +
+							self.Item2.Node.MaxSatisfactionSize(oneCost)
+						);
+				case OrD self:
+					return
+						Math.Max(
+							self.Item1.Node.MaxSatisfactionSize(oneCost),
+							self.Item1.Node.MaxDissatisfactionSize(oneCost).Value +
+							self.Item2.Node.MaxSatisfactionSize(oneCost)
+						);
+				case OrI self:
+					return
+						Math.Max(
+							oneCost + self.Item1.Node.MaxSatisfactionSize(oneCost),
+							1 + self.Item2.Node.MaxSatisfactionSize(oneCost)
+						);
+				case Thresh self:
+					return
+						self.Item2
+							.Select(sub =>
+								new {
+									Sat = sub.Node.MaxSatisfactionSize(oneCost),
+									Dissat = sub.Node.MaxDissatisfactionSize(oneCost).Value
+								})
+							.OrderBy(v => v.Sat - v.Dissat)
+							.Reverse()
+							.Select((v, i) => i < self.Item1 ? v.Sat : v.Dissat)
+							.Sum();
+				case ThreshM self : return 1 + 73 + (int)self.Item1;
+			}
+			throw new Exception("unreachable!");
+		}
+
+		public override string ToString()
+			=> ToStringCore(new StringBuilder()).ToString();
+
+		/// <summary>
+		/// Internal helper function for displaying wrapper types;
+		/// append a character to display before the `:` as well as a reference
+		/// to the wrapped type to allow easy recursion.
+		/// </summary>
+		/// <returns></returns>
+		private Tuple<char, Miniscript<TPk, TPKh>> WrapChar()
+		{
+			switch (this)
+			{
+				case Alt self: return Tuple.Create('a', self.Item);
+				case Swap self: return Tuple.Create('s', self.Item);
+				case Check self: return Tuple.Create('c', self.Item);
+				case DupIf self: return Tuple.Create('d', self.Item);
+				case Verify self: return Tuple.Create('v', self.Item);
+				case NonZero self: return Tuple.Create('j', self.Item);
+				case ZeroNotEqual self: return Tuple.Create('n', self.Item);
+				case AndV self:
+					return (self.Item2.Node == True) ? Tuple.Create('t', self.Item1) : null;
+				case OrI self:
+					return
+						(self.Item2.Node == False)
+							? Tuple.Create('u', self.Item1) :
+						(self.Item1.Node == False)
+							? Tuple.Create('l', self.Item2) : null;
+						;
+			}
+			return null;
+		}
+
+		private StringBuilder ToStringCore(StringBuilder sb)
+		{
+			switch (this.Tag)
+			{
+				case Tags.True: return sb.Append("1");
+				case Tags.False: return sb.Append("0");
+			}
+
+			switch (this)
+			{
+				case Pk self:
+					return sb.Append($"pk({self.Item})");
+				case PkH self:
+					return sb.Append($"pk_h({self.Item})");
+				case After self:
+					return sb.Append($"after({self.Item})");
+				case Older self:
+					return sb.Append($"older({self.Item})");
+				case Sha256 self:
+					return sb.Append($"sha256({self.Item})");
+				case Hash256 self:
+					return sb.Append($"hash256({self.Item})");
+				case Ripemd160 self:
+					return sb.Append($"ripemd160({self.Item})");
+				case Hash160 self:
+					return sb.Append($"hash160({self.Item})");
+				case AndV self when (!self.Item2.Node.Equals(True)):
+					sb.Append("and_v(");
+					self.Item1.Node.ToStringCore(sb);
+					sb.Append(",");
+					self.Item2.Node.ToStringCore(sb);
+					sb.Append(")");
+					return sb;
+				case AndB self:
+					sb.Append("and_b(");
+					self.Item1.Node.ToStringCore(sb);
+					sb.Append(",");
+					self.Item2.Node.ToStringCore(sb);
+					return sb.Append(")");
+				case AndOr self:
+					if (self.Item3.Node == False)
+					{
+						sb.Append("and_n(");
+						self.Item1.Node.ToStringCore(sb);
+						sb.Append(",");
+						self.Item2.Node.ToStringCore(sb);
+						return sb.Append(")");
+					}
+
+					sb.Append("andor(");
+					self.Item1.Node.ToStringCore(sb);
+					sb.Append(",");
+					self.Item2.Node.ToStringCore(sb);
+					sb.Append(",");
+					self.Item3.Node.ToStringCore(sb);
+					return sb.Append(")");
+				case OrB self:
+					sb.Append("or_b(");
+					self.Item1.Node.ToStringCore(sb);
+					sb.Append(",");
+					self.Item2.Node.ToStringCore(sb);
+					return sb.Append(")");
+				case OrD self:
+					sb.Append("or_d(");
+					self.Item1.Node.ToStringCore(sb);
+					sb.Append(",");
+					self.Item2.Node.ToStringCore(sb);
+					return sb.Append(")");
+				case OrC self:
+					sb.Append("or_c(");
+					self.Item1.Node.ToStringCore(sb);
+					sb.Append(",");
+					self.Item2.Node.ToStringCore(sb);
+					return sb.Append(")");
+				case OrI self when (self.Item1.Node != False && self.Item2.Node != False):
+					{
+						sb.Append("or_i(");
+						self.Item1.Node.ToStringCore(sb);
+						sb.Append(",");
+						self.Item2.Node.ToStringCore(sb);
+						sb.Append(")");
+						return sb;
+					}
+				case Thresh self:
+					sb.Append("thresh(");
+					sb.Append(self.Item1);
+					foreach (var sub in self.Item2)
+					{
+						sb.Append(",");
+						sub.Node.ToStringCore(sb);
+					}
+					return sb.Append(")");
+				case ThreshM self:
+					sb.Append("thresh_m(");
+					sb.Append(self.Item1);
+					foreach (var key in self.Item2)
+					{
+						sb.Append(",");
+						sb.Append(key.ToHex());
+					}
+					return sb.Append(")");
+			}
+			var t = WrapChar();
+			if (t is null)
+				throw new Exception("Unreachable!");
+			sb.Append(t.Item1);
+			if (t.Item2.Node.WrapChar() is null)
+				sb.Append(':');
+			return t.Item2.Node.ToStringCore(sb);
+		}
+
+		public string ToDebugString() =>
+			ToDebugStringCore(new StringBuilder()).ToString();
+
+		private StringBuilder ToDebugStringCore(StringBuilder sb)
+		{
+			var errors = new List<FragmentPropertyException>();
+			sb.Append("[");
+			if (Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(this, out var typeMap,
+				errors))
+			{
+				sb.Append(typeMap.Correctness.Base);
+				sb.Append("/");
+				sb.Append(typeMap.Correctness.Input.DebugPrint());
+				if (typeMap.Correctness.DisSatisfiable)
+					sb.Append('d');
+				if (typeMap.Correctness.Unit)
+					sb.Append('u');
+				sb.Append(typeMap.Malleability.Dissat.DebugPrint());
+				if (typeMap.Malleability.Safe)
+					sb.Append('s');
+				if (typeMap.Malleability.NonMalleable)
+					sb.Append('m');
+			}
+			else
+			{
+				sb.Append($"TYPECHECK FAILED {errors.Flatten()}");
+			}
+			sb.Append("]");
+
+			var t = WrapChar();
+			if (!(t is null))
+			{
+				sb.Append(t.Item1);
+				var sub = t.Item2;
+				if (sub.Node.WrapChar() is null)
+					sb.Append(":");
+				return sub.Node.ToDebugStringCore(sb);
+			}
+
+			switch (Tag)
+			{
+				case Tags.True : return sb.Append("1");
+				case Tags.False : return sb.Append("0");
+			}
+
+			switch (this)
+			{
+				case Pk self:
+					return sb.Append($"pk({self.Item})");
+				case PkH self:
+					return sb.Append($"pk_h({self.Item})");
+				case After self:
+					return sb.Append($"after({self.Item})");
+				case Older self:
+					return sb.Append($"older({self.Item})");
+				case Sha256 self:
+					return sb.Append($"sha256({self.Item})");
+				case Hash256 self:
+					return sb.Append($"hash256({self.Item})");
+				case Ripemd160 self:
+					return sb.Append($"ripemd160({self.Item})");
+				case Hash160 self:
+					return sb.Append($"hash160({self.Item})");
+				case AndV self:
+					sb.Append("and_v(");
+					self.Item1.Node.ToDebugStringCore(sb);
+					sb.Append(",");
+					self.Item2.Node.ToDebugStringCore(sb);
+					return sb.Append(")");
+				case AndB self:
+					sb.Append("and_b(");
+					self.Item1.Node.ToDebugStringCore(sb);
+					sb.Append(",");
+					self.Item2.Node.ToDebugStringCore(sb);
+					return sb.Append(")");
+				case AndOr self:
+					if (self.Item3.Node == False)
+					{
+						sb.Append("and_n(");
+						self.Item1.Node.ToDebugStringCore(sb);
+						sb.Append(",");
+						self.Item2.Node.ToDebugStringCore(sb);
+						return sb.Append(")");
+					}
+
+					sb.Append("andor(");
+					self.Item1.Node.ToDebugStringCore(sb);
+					sb.Append(",");
+					self.Item2.Node.ToDebugStringCore(sb);
+					sb.Append(",");
+					self.Item3.Node.ToDebugStringCore(sb);
+					return sb.Append(")");
+				case OrB self:
+					sb.Append("or_b(");
+					self.Item1.Node.ToDebugStringCore(sb);
+					sb.Append(",");
+					self.Item2.Node.ToDebugStringCore(sb);
+					return sb.Append(")");
+				case OrD self:
+					sb.Append("or_d(");
+					self.Item1.Node.ToDebugStringCore(sb);
+					sb.Append(",");
+					self.Item2.Node.ToDebugStringCore(sb);
+					return sb.Append(")");
+				case OrC self:
+					sb.Append("or_c(");
+					self.Item1.Node.ToDebugStringCore(sb);
+					sb.Append(",");
+					self.Item2.Node.ToDebugStringCore(sb);
+					return sb.Append(")");
+				case OrI self:
+					if (self.Item1.Node != False && self.Item2.Node != False)
+					{
+						sb.Append("or_i(");
+						self.Item1.Node.ToDebugStringCore(sb);
+						sb.Append(",");
+						self.Item2.Node.ToDebugStringCore(sb);
+						sb.Append(")");
+					}
+					return sb;
+				case Thresh self:
+					sb.Append("thresh(");
+					sb.Append(self.Item1);
+					foreach (var sub in self.Item2)
+					{
+						sb.Append(",");
+						sub.Node.ToDebugStringCore(sb);
+					}
+					return sb.Append(")");
+				case ThreshM self:
+					sb.Append("thresh_m(");
+					sb.Append(self.Item1);
+					foreach (var key in self.Item2)
+					{
+						sb.Append(",");
+						sb.Append(key.ToHex());
+					}
+					return sb.Append(")");
+			}
+
+			throw new Exception("Unreachable!");
+		}
+
+		internal static Terminal<TPk, TPKh> FromTree(Tree top)
+		{
+			string fragWrap = String.Empty;
+			string fragName = String.Empty;
+			var nameSplit = top.Name.Split(':');
+			if (nameSplit.Length == 1)
+			{
+				fragName = nameSplit[0];
+			}
+			else if (nameSplit.Length == 2)
+			{
+				if (nameSplit[0] == String.Empty)
+					throw new ParsingException($"unexpected fragment name {top.Name}");
+				fragWrap = nameSplit[0];
+				fragName = nameSplit[1];
+			}
+			else throw new ParsingException($"Found more `:` in fragment {top.Name}");
+
+			Terminal<TPk, TPKh> unwrapped = null;
+			switch (fragName)
+			{
+				case "pk":
+					if (top.Args.Count == 1)
+						unwrapped = Tree.Terminal(top.Args[0], x => NewPk(MiniscriptFragmentParser<TPk, TPKh>.ParseKey(x)));
+					break;
+				case "pk_h":
+					if (top.Args.Count == 1)
+						unwrapped = Tree.Terminal(top.Args[0], x => NewPkH(MiniscriptFragmentParser<TPk, TPKh>.ParseHash(x)));
+					break;
+				case "after":
+					if (top.Args.Count == 1)
+						unwrapped = Tree.Terminal(top.Args[0], x => NewAfter(UInt32.Parse(x)));
+					break;
+				case "older":
+					if (top.Args.Count == 1)
+						unwrapped = Tree.Terminal(top.Args[0], x => NewOlder(UInt32.Parse(x)));
+					break;
+				case "sha256":
+					if (top.Args.Count == 1)
+						unwrapped = Tree.Terminal(top.Args[0], x => NewSha256(new uint256(Hex.DecodeData(x), true)));
+					break;
+				case "hash256":
+					if (top.Args.Count == 1)
+						unwrapped = Tree.Terminal(top.Args[0], x => NewHash256(new uint256(Hex.DecodeData(x), true)));
+					break;
+				case "ripemd160":
+					if (top.Args.Count == 1)
+						unwrapped = Tree.Terminal(top.Args[0], x => NewRipemd160(new uint160(Hex.DecodeData(x), true)));
+					break;
+				case "hash160":
+					if (top.Args.Count == 1)
+						unwrapped = Tree.Terminal(top.Args[0], x => NewHash160(new uint160(Hex.DecodeData(x), true)));
+					break;
+				case "1":
+					if (top.Args.Count == 0)
+						unwrapped = Tree.Terminal(top.Args[0], _ => NewTrue());
+					break;
+				case "0":
+					if (top.Args.Count == 0)
+						unwrapped = Tree.Terminal(top.Args[0], _ => NewFalse());
+					break;
+				case "and_v":
+					if (top.Args.Count == 2)
+					{
+						var expr = Tree.Binary<TPk, TPKh>(top, NewAndV);
+						if (expr is AndV andv && andv.Item2.Node == True)
+							throw new ParsingException($"Non canonical true in {expr}");
+						unwrapped = expr;
+					}
+					break;
+				case "and_b":
+					if (top.Args.Count == 2)
+						unwrapped = Tree.Binary<TPk, TPKh>(top, NewAndB);
+					break;
+				case "and_n":
+					if (top.Args.Count == 2)
+						unwrapped =
+							Tree.Binary<TPk, TPKh>(
+								top,
+								(a, b) => NewAndOr(a, b, Miniscript<TPk, TPKh>.FromAst(NewFalse()))
+							);
+					break;
+				case "andor":
+					if (top.Args.Count == 3)
+						unwrapped = Tree.Ternary<TPk, TPKh>(top, NewAndOr);
+					break;
+				case "or_b":
+					if (top.Args.Count == 2)
+						unwrapped = Tree.Binary<TPk, TPKh>(top, NewOrB);
+					break;
+				case "or_d":
+					if (top.Args.Count == 2)
+						unwrapped = Tree.Binary<TPk, TPKh>(top, NewOrD);
+					break;
+				case "or_c":
+					if (top.Args.Count == 2)
+						unwrapped = Tree.Binary<TPk, TPKh>(top, NewOrC);
+					break;
+				case "or_i":
+					if (top.Args.Count == 2)
+					{
+						var expr = Tree.Binary<TPk, TPKh>(top, NewOrI);
+						if (expr is OrI ori && (ori.Item1.Node == False || ori.Item2.Node == False))
+							throw new ParsingException($"Non canonical false in {expr}");
+						unwrapped = expr;
+					}
+					break;
+				case "thresh":
+					var k = Tree.Terminal(top.Args[0], UInt32.Parse);
+					var n = top.Args.Count;
+					if (n == 0 || k > n - 1)
+						throw new ParsingException($"threshold ({k}) is higher than the number of sub exprs ({n})");
+					if (n == 1) throw new ParsingException("Empty thresholds not allowed in descriptors");
+					var subs = top.Args.Skip(1).Select(Miniscript<TPk, TPKh>.FromTree);
+					unwrapped = NewThresh(k, subs);
+					break;
+				case "thresh_m":
+					var km = Tree.Terminal(top.Args[0], UInt32.Parse);
+					var nm = top.Args.Count;
+					if (nm == 0 || km > nm - 1)
+						throw new ParsingException($"");
+					var subsm = top.Args.Skip(1).Select(sub => Tree.Terminal(sub, MiniscriptFragmentParser<TPk, TPKh>.ParseKey));
+					unwrapped = NewThreshM(km, subsm);
+					break;
+			}
+			if (unwrapped is null)
+				throw new ParsingException($"{top.Name}({top.Args.Count} args) while parsing Miniscript");
+
+			return fragWrap.ToCharArray().Reverse().Aggregate(unwrapped, (acc, ch) => WrapExpression(ch, acc));
+		}
+
+		private static Terminal<TPk, TPKh> WrapExpression(char wrapChar, Terminal<TPk, TPKh> t)
+		{
+			switch (wrapChar)
+			{
+				case 'a':
+					return NewAlt(Miniscript<TPk, TPKh>.FromAst(t));
+				case 's':
+					return NewSwap(Miniscript<TPk, TPKh>.FromAst(t));
+				case 'c':
+					return NewCheck(Miniscript<TPk, TPKh>.FromAst(t));
+				case 'd':
+					return NewDupIf(Miniscript<TPk, TPKh>.FromAst(t));
+				case 'v':
+					return NewVerify(Miniscript<TPk, TPKh>.FromAst(t));
+				case 'j':
+					return NewNonZero(Miniscript<TPk, TPKh>.FromAst(t));
+				case 'n':
+					return NewZeroNotEqual(Miniscript<TPk, TPKh>.FromAst(t));
+				case 't':
+					return NewAndV(
+						Miniscript<TPk, TPKh>.FromAst(t),
+						Miniscript<TPk, TPKh>.FromAst(NewTrue())
+						);
+				case 'u':
+					return NewOrI(
+						Miniscript<TPk, TPKh>.FromAst(t),
+						Miniscript<TPk, TPKh>.FromAst(NewFalse())
+						);
+				case 'l':
+					if (t == False)
+						throw new ParsingException($"Encountered l:o which is syntactically equal to `u:o` except stupid");
+					return NewOrI(
+						Miniscript<TPk, TPKh>.FromAst(NewFalse()),
+						Miniscript<TPk, TPKh>.FromAst(t)
+						);
+				default: throw new ParsingException($"Unknown wrapper {wrapChar}");
+			}
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Base.cs b/NBitcoin/Scripting/Miniscript/Base.cs
new file mode 100644
index 0000000000..09d44b840e
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Base.cs
@@ -0,0 +1,34 @@
+namespace NBitcoin.Scripting.Miniscript
+{
+	/// <summary>
+	/// Basic type representing where the fragment can go
+	/// </summary>
+	public enum Base
+	{
+		/// <summary>
+		/// Takes its inputs from the top of the stack.
+		/// Pushes nonzero if the condition is statisfied. If not, if it
+		/// does not abort, then 0 is pushed.
+		/// </summary>
+		B,
+		/// <summary>
+		/// Takes its inputs from the top of the stack. Pushes a
+		/// public key, regardless of satisfaction, onto the stack.
+		/// Must be wrapped in `c:` to turn into any other type.
+		/// </summary>
+		K,
+		/// <summary>
+		/// Takes its inputs from the top of the stack, which
+		/// must satisfy the condition (will abort otherwise).
+		/// Does not push anything onto the stack.
+		/// </summary>
+		V,
+		/// <summary>
+		/// Takes from the stack its inputs + element X at the top.
+		/// If the inputs satisfy the condition, [nonzero X] or
+		/// [X nonzero] is pushed. If not, if it does not abort,
+		/// then [0 X] or [X 0] is pushed.
+		/// </summary>
+		W
+	}
+}
\ No newline at end of file
diff --git a/NBitcoin/Scripting/Miniscript/ILiftable.cs b/NBitcoin/Scripting/Miniscript/ILiftable.cs
new file mode 100644
index 0000000000..405d6552dd
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/ILiftable.cs
@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NBitcoin.Scripting.Miniscript.Policy;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	public interface ILiftable<TPk, TPKh>
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
+	{
+		AbstractPolicy<TPk, TPKh> Lift();
+	}
+
+	public partial class Miniscript<TPk, TPKh> : ILiftable<TPk, TPKh>
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
+	{
+		public AbstractPolicy<TPk, TPKh> Lift() =>
+			this.Node.Lift();
+	}
+
+	public partial class Terminal<TPk, TPKh>
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
+	{
+		public AbstractPolicy<TPk, TPKh> Lift()
+		{
+			switch (this.Tag)
+			{
+				case Tags.True: return AbstractPolicy<TPk, TPKh>.Trivial;
+				case Tags.False: return AbstractPolicy<TPk, TPKh>.UnSatisfiable;
+			}
+
+			switch (this)
+			{
+				case Pk self: return AbstractPolicy<TPk, TPKh>.NewKeyHash(self.Item.ToPubKeyHash()).Normalize();
+				case PkH self: return AbstractPolicy<TPk, TPKh>.NewKeyHash(self.Item).Normalize();
+				case After self: return AbstractPolicy<TPk, TPKh>.NewAfter(self.Item).Normalize();
+				case Older self: return AbstractPolicy<TPk, TPKh>.NewOlder(self.Item).Normalize();
+				case Sha256 self: return AbstractPolicy<TPk, TPKh>.NewSha256(self.Item).Normalize();
+				case Hash256 self: return AbstractPolicy<TPk, TPKh>.NewHash256(self.Item).Normalize();
+				case Ripemd160 self: return AbstractPolicy<TPk, TPKh>.NewRipemd160(self.Item).Normalize();
+				case Hash160 self: return AbstractPolicy<TPk, TPKh>.NewHash160(self.Item).Normalize();
+				case Alt self: return self.Item.Node.Lift().Normalize();
+				case Swap self: return self.Item.Node.Lift().Normalize();
+				case Check self: return self.Item.Node.Lift().Normalize();
+				case DupIf self: return self.Item.Node.Lift().Normalize();
+				case Verify self: return self.Item.Node.Lift().Normalize();
+				case NonZero self: return self.Item.Node.Lift().Normalize();
+				case ZeroNotEqual self: return self.Item.Node.Lift().Normalize();
+				case AndV self:
+					return AbstractPolicy<TPk, TPKh>.NewAnd(new List<AbstractPolicy<TPk, TPKh>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift()}).Normalize();
+				case AndB self:
+					return AbstractPolicy<TPk, TPKh>.NewAnd(new List<AbstractPolicy<TPk, TPKh>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift()}).Normalize();
+				case AndOr self:
+					var inner = AbstractPolicy<TPk, TPKh>.NewAnd(new List<AbstractPolicy<TPk, TPKh>>() {self.Item1.Node.Lift(), self.Item3.Node.Lift()}).Normalize();
+					return AbstractPolicy<TPk, TPKh>.NewOr(new List<AbstractPolicy<TPk, TPKh>>() {inner, self.Item2.Node.Lift()}).Normalize();
+				case OrB self:
+					return AbstractPolicy<TPk, TPKh>.NewOr(new List<AbstractPolicy<TPk, TPKh>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() }).Normalize();
+				case OrD self:
+					return AbstractPolicy<TPk, TPKh>.NewOr(new List<AbstractPolicy<TPk, TPKh>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() }).Normalize();
+				case OrC self:
+					return AbstractPolicy<TPk, TPKh>.NewOr(new List<AbstractPolicy<TPk, TPKh>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() }).Normalize();
+				case OrI self:
+					return AbstractPolicy<TPk, TPKh>.NewOr(new List<AbstractPolicy<TPk, TPKh>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() }).Normalize();
+				case Thresh self:
+					return AbstractPolicy<TPk, TPKh>.NewThreshold(self.Item1, self.Item2.Select(sub => sub.Node.Lift()).ToList()).Normalize();
+				case ThreshM self:
+					return
+						AbstractPolicy<TPk, TPKh>.NewThreshold(
+							self.Item1,
+							self.Item2.Select(sub => AbstractPolicy<TPk, TPKh>.NewKeyHash(sub.ToPubKeyHash())).ToList()
+						).Normalize();
+			}
+
+			throw new Exception($"Unreachable! {this}");
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Input.cs b/NBitcoin/Scripting/Miniscript/Input.cs
new file mode 100644
index 0000000000..ff23eb7e13
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Input.cs
@@ -0,0 +1,41 @@
+namespace NBitcoin.Scripting.Miniscript
+{
+	/// <summary>
+	/// Type property representing exceptions about how many inputs
+	/// the fragment accepts, and assumptions about that.
+	/// </summary>
+	internal enum Input
+	{
+		Zero,
+		One,
+		Any,
+		OneNonZero,
+		AnyNonZero
+	}
+
+	internal static class InputExtension
+	{
+		public static string DebugPrint(this Input i)
+			=> (i == Input.Zero) ? "z" :
+				(i == Input.One) ? "o" :
+				(i == Input.OneNonZero) ? "on" :
+				(i == Input.Any) ? "" :
+				(i == Input.AnyNonZero) ? "n" : "";
+		public static bool IsSubtype(this Input self, Input other)
+		{
+			if (self == other)
+				return true;
+
+			if (self == Input.OneNonZero && other == Input.One)
+				return true;
+
+			if (self == Input.OneNonZero && other == Input.AnyNonZero)
+				return true;
+
+			if (other == Input.Any)
+				return true;
+
+			return false;
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
new file mode 100644
index 0000000000..ab046ab065
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using NBitcoin.Scripting.Miniscript.Types;
+using NBitcoin.Scripting.Parser;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	/// <summary>
+	/// Public facade for working with actual script fragment
+	/// </summary>
+	[DebuggerDisplay("{" + nameof(ToDebugString) + "()}")]
+	public partial class Miniscript<TPk, TPKh> : IEquatable<Miniscript<TPk, TPKh>>
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
+	{
+		internal readonly Terminal<TPk, TPKh> Node;
+		internal readonly MiniscriptFragmentType Type;
+
+		/// <summary>
+		/// Additional information helpful for extra analysis.
+		/// </summary>
+		/// <returns></returns>
+		internal readonly ExtData Ext;
+
+		internal Miniscript(MiniscriptFragmentType type, Terminal<TPk, TPKh> node, ExtData ext)
+		{
+			Type = type;
+			Node = node;
+			Ext = ext;
+		}
+
+		internal static Miniscript<TPk, TPKh> FromAst(Terminal<TPk, TPKh> t)
+		{
+			var errors = new List<FragmentPropertyException>();
+			if (Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(t, out var fragmentType, errors)
+				&& Property<ExtData, TPk, TPKh>.TypeCheck(t, out var extData, errors))
+				return
+					new Miniscript<TPk, TPKh>(
+						fragmentType,
+						t,
+						extData
+					);
+			throw errors.Flatten();
+		}
+
+		internal static Miniscript<TPk, TPKh> FromTree(Tree t)
+		{
+			var inner = Terminal<TPk, TPKh>.FromTree(t);
+			return FromAst(inner);
+		}
+		public static Miniscript<TPk, TPKh> Parse(string str)
+		{
+			try
+			{
+				var ms = FromTree(Tree.Parse(str));
+				if (ms.Type.Correctness.Base != Base.B)
+					throw new MiniscriptException.NonTopLevel(ms.Type.Correctness.Base.ToString("G"));
+				return ms;
+			} catch(FragmentPropertyException ex) {
+				throw new ParsingException("Failed to parse miniscript from ast", ex);
+			}
+		}
+
+		public Script ToScript() =>
+			Node.ToScript();
+
+		public override string ToString()
+			=> this.Node.ToString();
+
+		public string ToDebugString() =>
+			Node.ToDebugString();
+
+		public bool Equals(Miniscript<TPk, TPKh> other)
+			=> this.Node.Equals(other.Node);
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptError.cs b/NBitcoin/Scripting/Miniscript/MiniscriptError.cs
new file mode 100644
index 0000000000..63910cbebe
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptError.cs
@@ -0,0 +1,271 @@
+using System;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	public class MiniscriptException : Exception
+	{
+		internal static class Tags
+		{
+
+			internal const int InvalidOpcode = 0;
+			internal const int NonMinimalVerify = 1;
+			internal const int InvalidPush = 2;
+			internal const int PSBT = 3;
+			internal const int Script = 4;
+			internal const int CmsTooManyKeys = 5;
+			internal const int Unprintable = 6;
+			internal const int ExpectedChar = 7;
+			internal const int UnexpectedStart = 8;
+			internal const int Unexpected = 9;
+			internal const int MultiColon = 10;
+			internal const int MultiAt = 11;
+			internal const int AtOutsideOr = 12;
+			internal const int NonCanonicalTrue = 13;
+			internal const int NonCanonicalFalse = 14;
+			internal const int LikelyFalse = 15;
+			internal const int UnknownWrapper = 16;
+			internal const int NonTopLevel = 17;
+			internal const int Trailing = 18;
+			internal const int BadPubKey = 19;
+			internal const int MissingHash = 20;
+			internal const int MissingSig = 21;
+			internal const int RelativeLocktimeNotMet = 22;
+			internal const int AbsoluteLockTimeNotMet = 23;
+			internal const int CouldNotSatisfy = 24;
+			internal const int TypeCheck = 25;
+			internal const int BadDescriptor = 26;
+			internal const int CompileError = 27;
+			internal const int InterpreterError = 28;
+			internal const int BadScriptSig = 29;
+			internal const int NonEmptyWitness = 30;
+			internal const int NonEmptyScriptSig = 31;
+			internal const int IncorrectPubkeyHash = 32;
+			internal const int IncorrectScriptHash = 33;
+		}
+
+		internal int Tag;
+
+		/// <summary>
+		/// While parsing backward, hit beginning of the script.
+		/// </summary>
+		public static MiniscriptException UnexpectedStart = new MiniscriptException(Tags.UnexpectedStart);
+
+		/// <summary>
+		/// Fragment was an `and_v(_, true)` which should be written as `t:`
+		/// </summary>
+		public static MiniscriptException NonCanonicalTrue = new MiniscriptException(Tags.NonCanonicalTrue);
+
+		/// <summary>
+		/// NFragment was an `or_i(_, false)` or `or_i(false, _)` which should be written as `u:` or `l:`
+		/// </summary>
+		public static MiniscriptException NonCanonicalFalse = new MiniscriptException(Tags.NonCanonicalFalse);
+
+		/// <summary>
+		/// Encountered a `l:0` which is syntactically equal to `u:0` except stupid
+		/// </summary>
+		public static MiniscriptException LikelyFalse = new MiniscriptException(Tags.LikelyFalse);
+
+		/// <summary>
+		/// General failure to satisfy
+		/// </summary>
+		public static MiniscriptException CouldNotSatisfy = new MiniscriptException(Tags.CouldNotSatisfy);
+
+		/// <summary>
+		/// General error in creating descriptor
+		/// </summary>
+		public static MiniscriptException BadDescriptor = new MiniscriptException(Tags.BadDescriptor);
+
+		/// <summary>
+		/// Bad Script Sig. As per standardness rules, only pushes are allowed in scriptSig.
+		/// This error is invoked when opc_codes are pushed onto the stack As per the current
+		/// implementation, pushing an integer apart from 0 or 1will also trigger this.
+		/// This is because, Miniscript only expects push bytes for pk, sig, preimage etc or 1 or 0
+		/// for `StackElement:Satisfied` or `StackElement::Dissatisfied`
+		/// </summary>
+		public static MiniscriptException BadScriptSig = new MiniscriptException(Tags.BadScriptSig);
+
+		/// <summary>
+		/// Witness must be empty for pre-segwit transactions
+		/// </summary>
+		public static MiniscriptException NonEmptyWitness = new MiniscriptException(Tags.NonEmptyWitness);
+
+		/// <summary>
+		/// ScriptSig must be empty for pure segwit transactions.
+		/// </summary>
+		public static MiniscriptException NonEmptyScriptSig = new MiniscriptException(Tags.NonEmptyScriptSig);
+
+		/// <summary>
+		/// Incorrect Script Pubkey Hash for the descriptor. This is used for both
+		/// `PkH` and `Wpkh` descriptors.
+		/// </summary>
+		public static MiniscriptException IncorrectPubkeyHash = new MiniscriptException(Tags.IncorrectPubkeyHash);
+
+		/// <summary>
+		/// Incorrect Script pubkey Hash for the descriptor. This is used for both
+		/// `Sh` and `Wsh` descriptors.
+		/// </summary>
+		public static MiniscriptException IncorrectScriptHash = new MiniscriptException(Tags.IncorrectScriptHash);
+
+		private MiniscriptException(int tag) => Tag = tag;
+
+		/// <summary>
+		/// Opcode appeared which is not part of the script subset.
+		/// </summary>
+		internal class InvalidOpcode : MiniscriptException
+		{
+			public OpcodeType Item;
+			public InvalidOpcode(OpcodeType item) : base(Tags.InvalidOpcode) => Item = item;
+		}
+
+		/// <summary>
+		/// Some opcode occured followed by `OP_VERIFY` when it had
+		/// a `VERIFY` version that should have been used instead.
+		/// </summary>
+		internal class NonMinimalVerify : MiniscriptException
+		{
+			public ScriptToken Item;
+			public NonMinimalVerify(ScriptToken item) : base(Tags.NonMinimalVerify) => Item = item;
+		}
+
+		/// <summary>
+		/// Push was illegal in some context
+		/// </summary>
+		internal class InvalidPush : MiniscriptException
+		{
+			public byte[] Item;
+			public InvalidPush(byte[] item) : base(Tags.InvalidPush) => Item = item;
+		}
+
+		/// <summary>
+		///  PSBT related error
+		/// </summary>
+		internal class PSBT : MiniscriptException
+		{
+			public PSBTError Item;
+			public PSBT(PSBTError item) : base(Tags.PSBT) => Item = item;
+		}
+
+		internal class Script : MiniscriptException
+		{
+			public ScriptError Item;
+			public Script(ScriptError item) : base(Tags.Script) => Item = item;
+		}
+
+		internal class CmsTooManyKeys : MiniscriptException
+		{
+			public uint Item;
+
+			public CmsTooManyKeys(uint item) : base(Tags.CmsTooManyKeys) => Item = item;
+		}
+
+		internal class Unprintable : MiniscriptException
+		{
+			public byte Item;
+
+			public Unprintable(byte item) : base (Tags.Unprintable) => Item = item;
+		}
+
+		internal class ExpectedChar : MiniscriptException
+		{
+			public char Item;
+
+			public ExpectedChar(char item) : base(Tags.ExpectedChar) => Item = item;
+		}
+
+		internal class Unexpected : MiniscriptException
+		{
+			public string Item;
+
+			public Unexpected(string item) : base(Tags.Unexpected) => Item = item;
+		}
+
+		internal class MultiColon : MiniscriptException
+		{
+			public string Item;
+
+			public MultiColon(string item) : base(Tags.MultiColon) => Item = item;
+		}
+
+		internal class MultiAt : MiniscriptException
+		{
+			public string Item;
+			internal MultiAt(string item) : base(Tags.MultiAt) => Item = item;
+		}
+
+		internal class AtOutsideOr : MiniscriptException
+		{
+			public string Item;
+			internal AtOutsideOr(string item) : base(Tags.AtOutsideOr) => Item = item;
+		}
+
+		internal class UnknownWrapper : MiniscriptException
+		{
+			public char Item;
+			public UnknownWrapper(char item) : base(Tags.UnknownWrapper) => Item = item;
+		}
+
+		internal class NonTopLevel : MiniscriptException
+		{
+			public string Item;
+			public NonTopLevel(string item) : base(Tags.NonTopLevel) => Item = item;
+		}
+
+		internal class Trailing : MiniscriptException
+		{
+			public string Item;
+			public Trailing(string item) : base(Tags.Trailing) => Item = item;
+		}
+
+		internal class BadPubKey : MiniscriptException
+		{
+			public FormatException Item;
+			public BadPubKey(FormatException item) : base(Tags.BadPubKey) => Item = item;
+		}
+
+		internal class MissingHash : MiniscriptException
+		{
+			public uint256 Item;
+
+			public MissingHash(uint256 item) : base(Tags.MissingHash) => Item = item;
+		}
+
+		internal class MissingSig : MiniscriptException
+		{
+			public PubKey Item;
+
+			public MissingSig(PubKey item) : base(Tags.MissingSig) => Item = item;
+		}
+
+		internal class RelativeLockTimeNotMet : MiniscriptException
+		{
+			public uint Item;
+			public RelativeLockTimeNotMet(uint item) : base(Tags.RelativeLocktimeNotMet) => Item = item;
+		}
+
+		internal class AbsoluteLockTimeNotMet : MiniscriptException
+		{
+			public uint Item;
+			public AbsoluteLockTimeNotMet(uint item) : base(Tags.AbsoluteLockTimeNotMet) => Item = item;
+		}
+
+		internal class TypeCheck : MiniscriptException
+		{
+			public string Item;
+			public TypeCheck(string item) : base(Tags.TypeCheck) => Item = item;
+		}
+
+		internal class CompileError : MiniscriptException
+		{
+			public Policy.CompilerException Item;
+
+			public CompileError(Policy.CompilerException item) : base (Tags.CompileError) => Item = item;
+		}
+
+		internal class InterpreterError : MiniscriptException
+		{
+			public InterpreterError Item;
+
+			public InterpreterError(InterpreterError item) : base(Tags.InterpreterError) => Item = item;
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
new file mode 100644
index 0000000000..cc99a92fde
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
@@ -0,0 +1,155 @@
+using System;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	public interface IMiniscriptKeyHash
+	{
+		uint160 ToHash160();
+		string ToHex();
+	}
+
+	/// <summary>
+	/// Interface to abstract a PubKey in Miniscript
+	/// When we are dealing with Miniscript directly without output descriptor, pubkey is directly hex
+	/// encoded. But when we are parsing Output Descriptor, we may want to parse a xpub (or other similar encodings)
+	/// So we must not hold pubkey directly.
+	/// </summary>
+	public interface IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
+	{
+		TPKh ToPubKeyHash();
+
+		/// <summary>
+		/// Converts an object to public key
+		/// </summary>
+		/// <returns></returns>
+		PubKey ToPublicKey();
+
+		/// <summary>
+		/// Computes the size of a public key when serialized in a script,
+		/// including the length bytes
+		/// </summary>
+		/// <returns></returns>
+		int SerializedLength();
+
+		string ToHex();
+
+		bool Equals(IMiniscriptKey<TPKh> other);
+	}
+
+	public class MiniscriptStringKeyHash : IMiniscriptKeyHash
+	{
+		public readonly string Text;
+		public MiniscriptStringKeyHash() {}
+
+		public MiniscriptStringKeyHash(string text)
+		{
+			Text = text;
+		}
+
+		public uint160 ToHash160()
+		{
+			throw new NotSupportedException();
+		}
+
+		public string ToHex() => Text;
+
+		public static MiniscriptStringKeyHash Parse(string str) => new MiniscriptStringKeyHash(str);
+	}
+	public class MiniscriptStringKey : IMiniscriptKey<MiniscriptStringKeyHash>
+	{
+		public readonly string Text;
+
+		public MiniscriptStringKey() {}
+		public MiniscriptStringKey(string text)
+		{
+			Text = text;
+		}
+
+		public MiniscriptStringKeyHash ToPubKeyHash() =>
+			new MiniscriptStringKeyHash($"<{Text}>");
+
+		public PubKey ToPublicKey()
+		{
+			throw new NotSupportedException();
+		}
+
+		public int SerializedLength()
+		{
+			throw new NotSupportedException();
+		}
+
+		public string ToHex() => Text;
+
+		public bool Equals(IMiniscriptKey<MiniscriptStringKeyHash> other)
+		{
+			return Equals(other as MiniscriptStringKey);
+		}
+
+
+		public static MiniscriptStringKey Parse(string str)
+			=> new MiniscriptStringKey(str);
+	}
+	/// <summary>
+	/// Dummy key which de/serializes to the empty string; useful sometimes for testing.
+	/// </summary>
+	internal class DummyKeyHash : IMiniscriptKeyHash
+
+	{
+		public uint160 ToHash160() => new uint160();
+		public string ToHex() => "";
+		public override string ToString() => "";
+	}
+	internal class DummyKey : IMiniscriptKey<DummyKeyHash>
+	{
+		public bool Equals(IMiniscriptKey<DummyKeyHash> other) => true;
+
+		public int SerializedLength() => 33;
+
+		public string ToHex() => "";
+		public override string ToString() => "";
+
+		public DummyKeyHash ToPubKeyHash() => new DummyKeyHash();
+
+		public PubKey ToPublicKey() => new PubKey("0250863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352");
+	}
+	public static partial class MiniscriptFragmentParser<TPk, TPKh>
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
+	{
+		private static DataEncoders.HexEncoder Hex = new DataEncoders.HexEncoder();
+		public static TPk ParseKey(string str)
+		{
+			var t = new TPk();
+			if (t is PubKey)
+			{
+				return new PubKey(str) as TPk;
+			}
+
+			if (t is MiniscriptStringKey)
+			{
+				return MiniscriptStringKey.Parse(str) as TPk;
+			}
+			if (t is DummyKey)
+			{
+				return t;
+			}
+			throw new NotSupportedException();
+		}
+
+		public static TPKh ParseHash(string str)
+		{
+			var t = new TPKh();
+			if (t is uint160)
+				return new uint160(Hex.DecodeData(str), true) as TPKh;
+			if (t is MiniscriptStringKeyHash)
+				return MiniscriptStringKeyHash.Parse(str) as TPKh;
+			if (t is DummyKeyHash)
+			{
+				return t;
+			}
+			throw new NotSupportedException();
+		}
+
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs b/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
new file mode 100644
index 0000000000..858531720d
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
@@ -0,0 +1,459 @@
+using System;
+using System.Collections.Generic;
+using NBitcoin.Scripting.Miniscript.Types;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	internal static class MiniscriptScriptParser
+	{
+		/*
+
+		private static readonly Parser<ScriptToken, uint> PNumber =
+			from t in Parse.ScriptToken(ScriptToken.Tags.Number)
+			select ((ScriptToken.Number)t).Item;
+
+		private static readonly Parser<ScriptToken, uint256> PHash =
+			from t in Parse.ScriptToken(ScriptToken.Tags.Hash32)
+			select ((ScriptToken.Hash32)t).Item;
+		private static readonly Parser<ScriptToken, PubKey> PPubKey =
+			from t in Parse.ScriptToken(ScriptToken.Tags.Pk)
+			select ((ScriptToken.Pk)t).Item;
+
+		private static readonly P PAndBool =
+				from _ in Parse.ScriptToken(ScriptToken.BoolAnd)
+				from w in Parse.Ref(() => PW)
+				from e in ParseShortestE
+				select AstElem.NewAndBool(e, w);
+
+		private static readonly P POrBool =
+				from _ in Parse.ScriptToken(ScriptToken.BoolOr)
+				from w in Parse.Ref(() => PW)
+				from e in ParseShortestE
+				select AstElem.NewOrBool(e, w);
+
+		internal static readonly P PHashT =
+				from _1 in Parse.ScriptToken(ScriptToken.Equal)
+				from hash in PHash
+				from _2 in Parse.ScriptToken(ScriptToken.Sha256)
+				from _3 in Parse.ScriptToken(ScriptToken.EqualVerify)
+				from num in PNumber
+				where num == 32
+				from _4 in Parse.ScriptToken(ScriptToken.Size)
+				select AstElem.NewHashT(hash);
+
+		private static readonly Parser<ScriptToken, AstElem[]> ThreshSubExpr =
+				from ws in
+					(Parse.ScriptToken(ScriptToken.Add).Then(_ => Parse.Ref(() => PW))).AtLeastOnce()
+				from e in Parse.Ref(() => ParseShortestE).Once()
+				select e.Concat(ws.Reverse()).ToArray();
+		internal static readonly P PThresh =
+				from _ in Parse.ScriptToken(ScriptToken.Equal)
+				from num in PNumber
+				from subExprs in Parse.Ref(() => ThreshSubExpr)
+				select (AstElem.NewThresh(num, subExprs));
+
+		private static readonly P PHashV =
+				from _1 in Parse.ScriptToken(ScriptToken.EqualVerify)
+				from hash in PHash
+				from _2 in Parse.ScriptToken(ScriptToken.Sha256)
+				from _3 in Parse.ScriptToken(ScriptToken.EqualVerify)
+				from num in PNumber
+				where num == 32
+				from _4 in Parse.ScriptToken(ScriptToken.Size)
+				select AstElem.NewHashV(hash);
+
+		private static readonly P PThreshV =
+				from _1 in Parse.ScriptToken(ScriptToken.EqualVerify)
+				from num in PNumber
+				from subExprs in Parse.Ref(() => ThreshSubExpr)
+				select AstElem.NewThreshV(num, subExprs);
+
+		private static readonly P PPkHelper =
+				from _1 in Parse.ScriptToken(ScriptToken.CheckSig)
+				from pk in PPubKey
+				select AstElem.NewPk(pk);
+		private static readonly P PPkW =
+				from _1 in Parse.ScriptToken(ScriptToken.CheckSig)
+				from pk in PPubKey
+				from _2 in Parse.ScriptToken(ScriptToken.Swap)
+				select AstElem.NewPkW(pk);
+
+		internal static readonly P PPk =
+				from ppk in PPkHelper.Except(Parse.Ref(() => PPkV))
+				select ppk;
+
+		private static readonly P POrKey =
+				from _1 in Parse.ScriptToken(ScriptToken.CheckSig)
+				from _2 in Parse.ScriptToken(ScriptToken.EndIf)
+				from qR in Parse.Ref(() => PQ)
+				from _3 in Parse.ScriptToken(ScriptToken.Else)
+				from qL in Parse.Ref(() => PQ)
+				from _4 in Parse.ScriptToken(ScriptToken.If)
+				select AstElem.NewOrKey(qL, qR);
+		private static readonly P PPkV =
+				from _1 in Parse.ScriptToken(ScriptToken.CheckSigVerify)
+				from pk in PPubKey
+				select AstElem.NewPkV(pk);
+
+		private static readonly P POrKeyV =
+				from _1 in Parse.ScriptToken(ScriptToken.CheckSigVerify)
+				from _2 in Parse.ScriptToken(ScriptToken.EndIf)
+				from qR in Parse.Ref(() => PQ)
+				from _3 in Parse.ScriptToken(ScriptToken.Else)
+				from qL in Parse.Ref(() => PQ)
+				from _4 in Parse.ScriptToken(ScriptToken.If)
+				select AstElem.NewOrKeyV(qL, qR);
+
+		private static readonly Parser<ScriptToken, Tuple<uint, PubKey[]>> PMultiHelper =
+				from n in PNumber
+				from pksStk in Parse.ScriptToken(ScriptToken.Tags.Pk).Repeat((int)n)
+				from m in PNumber
+				let pks = pksStk.Select(pkStk => ((ScriptToken.Pk)pkStk).Item).Reverse().ToArray()
+				select Tuple.Create(m, pks);
+		internal static readonly P PMulti =
+				from _1 in Parse.ScriptToken(ScriptToken.CheckMultiSig)
+				from t in PMultiHelper
+				select AstElem.NewMulti(t.Item1, t.Item2);
+
+		private static readonly P PMultiV =
+				from _1 in Parse.ScriptToken(ScriptToken.CheckMultiSigVerify)
+				from t in PMultiHelper
+				select AstElem.NewMultiV(t.Item1, t.Item2);
+
+		private static readonly P PTimeF =
+				from _1 in Parse.ScriptToken(ScriptToken.ZeroNotEqual)
+				from _2 in Parse.ScriptToken(ScriptToken.CheckSequenceVerify)
+				from n in PNumber
+				select AstElem.NewTimeF(n);
+
+		internal static readonly P PTimeT =
+				from _1 in Parse.ScriptToken(ScriptToken.CheckSequenceVerify)
+				from n in PNumber
+				select AstElem.NewTimeT(n);
+
+		internal static readonly P PWrap =
+				from _1 in Parse.ScriptToken(ScriptToken.FromAltStack)
+				from e in ParseShortestE
+				from _2 in Parse.ScriptToken(ScriptToken.ToAltStack)
+				select AstElem.NewWrap(e);
+
+		private static readonly P PTimeV =
+			from _1 in Parse.ScriptToken(ScriptToken.Drop)
+			from _2 in Parse.ScriptToken(ScriptToken.CheckSequenceVerify)
+			from num in PNumber
+			select AstElem.NewTimeV(num);
+		private static readonly Parser<ScriptToken, uint> PTimeHelper =
+				from _0 in Parse.ScriptToken(ScriptToken.EndIf)
+				from _1 in Parse.ScriptToken(ScriptToken.Drop)
+				from _2 in Parse.ScriptToken(ScriptToken.CheckSequenceVerify)
+				from n in PNumber
+				from _3 in Parse.ScriptToken(ScriptToken.If)
+				from _4 in Parse.ScriptToken(ScriptToken.Dup)
+				select n;
+		private static readonly P PTimeW =
+				from n in PTimeHelper
+				from _1 in Parse.ScriptToken(ScriptToken.Swap)
+				select AstElem.NewTimeW(n);
+
+		private static readonly P PTime =
+			from n in PTimeHelper.Except(PTimeW)
+			select AstElem.NewTime(n);
+
+		private static readonly P PLikelyHelper =
+				from _1 in Parse.ScriptToken(ScriptToken.EndIf)
+				from n in PNumber
+				where n == 0
+				from _2 in Parse.ScriptToken(ScriptToken.Else)
+				from f in Parse.Ref(() => PF)
+				select f;
+		private static readonly P PUnlikely =
+				from f in PLikelyHelper
+				from _ in Parse.ScriptToken(ScriptToken.If)
+				select AstElem.NewUnlikely(f);
+		private static readonly P PLikely =
+				from f in PLikelyHelper
+				from _ in Parse.ScriptToken(ScriptToken.NotIf)
+				select AstElem.NewLikely(f);
+
+		private static readonly P POrIfOfQ =
+				from _1 in Parse.ScriptToken(ScriptToken.EndIf)
+				from qr in Parse.Ref(() => PQ)
+				from _2 in Parse.ScriptToken(ScriptToken.Else)
+				from ql in Parse.Ref(() => PQ)
+				from _3 in Parse.ScriptToken(ScriptToken.If)
+				select AstElem.NewOrIf(ql, qr);
+
+		private static readonly P PHashW =
+				from _1 in Parse.ScriptToken(ScriptToken.EndIf)
+				from f in Parse.Ref(() => PF)
+				from _2 in Parse.ScriptToken(ScriptToken.If)
+				from _3 in Parse.ScriptToken(ScriptToken.ZeroNotEqual)
+				from _4 in Parse.ScriptToken(ScriptToken.Size)
+				from _5 in Parse.ScriptToken(ScriptToken.Swap)
+				where f.IsTrue()
+				let inner = ((AstElem.True)f).Item1
+				where inner.IsHashV()
+				let hash = ((AstElem.HashV)inner).Item1
+				select AstElem.NewHashW(hash);
+
+		private static readonly P PAndCascSub =
+				from _1 in Parse.ScriptToken(ScriptToken.EndIf)
+				from f in Parse.Ref(() => PF)
+				from _3 in Parse.ScriptToken(ScriptToken.Else)
+				select f;
+		internal static readonly P PAndCasc =
+				from f in PAndCascSub
+				from n in PNumber
+				where n == 0
+				from _4 in Parse.ScriptToken(ScriptToken.NotIf)
+				from e in ParseShortestE
+				select AstElem.NewAndCasc(e, f);
+
+		internal static readonly P POrIfOfEF =
+				from _1 in Parse.ScriptToken(ScriptToken.EndIf)
+				from r in Parse.Ref(() => PE)
+				from _2 in Parse.ScriptToken(ScriptToken.Else)
+				from l in Parse.Ref(() => PF)
+				from _3 in Parse.ScriptToken(ScriptToken.If)
+				select AstElem.NewOrIf(l, r);
+
+		internal static readonly P POrIfOfF =
+				from _1 in Parse.ScriptToken(ScriptToken.EndIf)
+				from r in Parse.Ref(() => PF)
+				from _2 in Parse.ScriptToken(ScriptToken.Else)
+				from l in Parse.Ref(() => PF)
+				from _3 in Parse.ScriptToken(ScriptToken.If)
+				select AstElem.NewOrIf(l, r);
+		internal static readonly P POrNotIf =
+				from _1 in Parse.ScriptToken(ScriptToken.EndIf)
+				from er in Parse.Ref(() => PE)
+				from _2 in Parse.ScriptToken(ScriptToken.Else)
+				from fl in Parse.Ref(() => PF)
+				from _3 in Parse.ScriptToken(ScriptToken.NotIf)
+				select AstElem.NewOrNotIf(fl, er);
+
+		private static readonly P POrIfOfV =
+				from _1 in Parse.ScriptToken(ScriptToken.EndIf)
+				from vr in Parse.Ref(() => PV)
+				from _2 in Parse.ScriptToken(ScriptToken.Else)
+				from vl in Parse.Ref(() => PV)
+				from _3 in Parse.ScriptToken(ScriptToken.If)
+				select AstElem.NewOrIf(vl, vr);
+
+		internal static readonly P POrCont =
+				from _1 in Parse.ScriptToken(ScriptToken.EndIf)
+				from vr in Parse.Ref(() => PV)
+				from _2 in Parse.ScriptToken(ScriptToken.NotIf)
+				from el in ParseShortestE
+				select AstElem.NewOrCont(el, vr);
+
+		internal static readonly P POrIfOfT =
+				from _1 in Parse.ScriptToken(ScriptToken.EndIf)
+				from tr in Parse.Ref(() => PT)
+				from _2 in Parse.ScriptToken(ScriptToken.Else)
+				from tl in Parse.Ref(() => PT)
+				from _3 in Parse.ScriptToken(ScriptToken.If)
+				select AstElem.NewOrIf(tl, tr);
+		private static readonly P POrCasc =
+				from _1 in Parse.ScriptToken(ScriptToken.EndIf)
+				from tr in Parse.Ref(() => PT)
+				from _2 in Parse.ScriptToken(ScriptToken.NotIf)
+				from _3 in Parse.ScriptToken(ScriptToken.IfDup)
+				from el in ParseShortestE
+				select AstElem.NewOrCasc(el, tr);
+
+		private static readonly P POrIfV =
+				from _1 in Parse.ScriptToken(ScriptToken.Verify)
+				from _2 in Parse.ScriptToken(ScriptToken.EndIf)
+				from tr in Parse.Ref(() => PT)
+				from _3 in Parse.ScriptToken(ScriptToken.Else)
+				from tl in Parse.Ref(() => PT)
+				from _4 in Parse.ScriptToken(ScriptToken.If)
+				select AstElem.NewOrIfV(tl, tr);
+
+		internal static readonly P PTrue =
+				from n in PNumber
+				where n == 1
+				from v in Parse.Ref(() => PV)
+				select AstElem.NewTrue(v);
+
+		private static readonly P PPkQ =
+				from pk in PPubKey
+				select AstElem.NewPkQ(pk);
+
+		private static readonly P PW =
+				from expr in Parse.Ref(() => PAstElem)
+				where expr.IsW()
+				select expr;
+
+		private static readonly P PF =
+				from expr in Parse.Ref(() => PAstElem)
+				where expr.IsF()
+				select expr;
+
+		private static readonly P PQ =
+				from expr in Parse.Ref(() => PAstElem)
+				where expr.IsQ()
+				select expr;
+
+		private static readonly P PE =
+				from expr in Parse.Ref(() => PAstElem)
+				where expr.IsE()
+				select expr;
+
+		private static readonly P PV =
+				from expr in Parse.Ref(() => PAstElem)
+				where expr.IsV()
+				select expr;
+
+		internal static readonly P PT =
+				from expr in Parse.Ref(() => PAstElem)
+				where expr.IsT()
+				select expr;
+
+		private static readonly P PENoPostProcess =
+			from expr in Parse.Ref(() => PAstElemCore)
+			where expr.IsE()
+			select expr;
+		private static readonly P ParseShortestE =
+			from e in Parse.Ref(() => PENoPostProcess).Or(Parse.Ref(() => PE))
+			select e;
+		internal static readonly P PAstElemCore =
+				PAndBool
+					.Or(POrBool)
+					.Or(PHashT)
+					.Or(PThresh)
+					.Or(PHashV)
+					.Or(PThreshV)
+					.Or(PPkW)
+					.Or(PPk)
+					.Or(POrKey)
+					.Or(PPkV)
+					.Or(POrKeyV)
+					.Or(PMulti)
+					.Or(PMultiV)
+					.Or(PTimeF)
+					.Or(PTimeT)
+					.Or(PWrap)
+					.Or(PTimeV)
+					.Or(PTimeW)
+					.Or(PTime)
+					.Or(PUnlikely)
+					.Or(PLikely)
+					.Or(POrIfOfQ)
+					.Or(PHashW)
+					.Or(PAndCasc)
+					.Or(POrIfOfF)
+					.Or(POrIfOfEF)
+					.Or(POrNotIf)
+					.Or(POrIfOfV)
+					.Or(POrCont)
+					.Or(POrIfOfT)
+					.Or(POrCasc)
+					.Or(POrIfV)
+					.Or(PTrue)
+					.Or(PPkQ);
+
+		private static P PostProcess(AstElem ast)
+			=> (IInput<ScriptToken> i) =>
+			{
+				if (i.AtEnd)
+					return ParserResult<ScriptToken, AstElem>.Success(i, ast);
+				if (ast.IsT() || ast.IsF() || ast.IsV() || ast.IsQ())
+				{
+					var next = i.GetCurrent();
+					if (next.Equals(ScriptToken.If) || next.Equals(ScriptToken.NotIf) || next.Equals(ScriptToken.Else) || next.Equals(ScriptToken.ToAltStack))
+						return ParserResult<ScriptToken, AstElem>.Success(i, ast);
+					else
+					{
+						var leftResult = PAstElem(i);
+						if (leftResult.IsSuccess)
+						{
+							var left = leftResult.Value;
+							if (!left.IsV())
+							{
+								return ParserResult<ScriptToken, AstElem>.Failure(i, "SubExpression was not V");
+							}
+							return ParserResult<ScriptToken, AstElem>.Success(leftResult.Rest, AstElem.NewAndCat(left, ast));
+						}
+						return leftResult;
+					}
+				}
+				else
+					return ParserResult<ScriptToken, AstElem>.Success(i, ast);
+			};
+		internal static readonly P PAstElem =
+			PAstElemCore.Bind(ast => Parse.Ref(() => PostProcess(ast)));
+
+		public static AstElem ParseScript(Script sc)
+			=> PT.Parse(sc);
+
+
+		public static Terminal<TPk, TPKh> ParseScript<TPk, TPKh>(Script sc)
+			where TPk : IMiniscriptKey<TPKh>
+			where TPKh : IMiniscriptKeyHash
+			=>
+			throw new NotImplementedException();
+
+		private class TerminalStack<TPk, TPKh>
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
+		{
+			internal readonly Stack<Miniscript<TPk, TPKh>> Inner;
+			internal TerminalStack(Stack<Miniscript<TPk, TPKh>> inner)
+			{
+				Inner = inner;
+			}
+
+			internal Miniscript<TPk, TPKh> Pop() =>
+				this.Inner.Pop();
+
+			internal void Reduce0(Terminal<TPk, TPKh> ms)
+			{
+				MiniscriptFragmentType ty = default;
+				ty = ty.TypeCheck(ms, _ => null);
+				ExtData ext = default;
+				ext = ext.TypeCheck(ms, _ => null);
+				this.Inner.Push(new Miniscript<TPk, TPKh>(ty, ms, ext));
+			}
+
+			internal void Reduce1(Func<Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> wrap)
+			{
+				throw new NotImplementedException();
+			}
+
+			internal void Reduce2(Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> wrap)
+			{
+				throw new NotImplementedException();
+			}
+		}
+
+		private static T MatchToken<T>(Func<T> f) => f.Invoke();
+
+		private static void MatchToken(ScriptToken tokens)
+		{
+			throw new NotImplementedException();
+		}
+		public static Miniscript<TPk, TPKh> ParseScriptToken<TPk, TPKh>(ScriptToken sct)
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
+		{
+			var nonTerm = new Stack<NonTerm>();
+			var term = new TerminalStack<TPk, TPKh>(new Stack<Miniscript<TPk, TPKh>>());
+
+			nonTerm.Push(NonTerm.MaybeAndV);
+			nonTerm.Push(NonTerm.MaybeSwap);
+			nonTerm.Push(NonTerm.Expression);
+			while (true)
+			{
+				if (nonTerm.Count == 0)
+					break;
+				var popped = nonTerm.Pop();
+				if (popped == NonTerm.Expression)
+				{}
+			}
+			throw new NotImplementedException();
+		}
+		*/
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
new file mode 100644
index 0000000000..62a9729724
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
@@ -0,0 +1,451 @@
+using System;
+using System.Text;
+using System.Collections.Generic;
+using System.Linq;
+using NBitcoin.BouncyCastle.Asn1;
+using NBitcoin.Scripting.Parser;
+
+
+namespace NBitcoin.Scripting.Miniscript.Policy
+{
+	public class AbstractPolicy<TPk, TPKh> : IEquatable<AbstractPolicy<TPk, TPKh>>
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
+	{
+		#region Subtype definitions
+		internal static class Tags
+		{
+			public const int Unsatisfiable = 0;
+			public const int Trivial = 1;
+			public const int KeyHash = 2;
+			public const int After = 3;
+			public const int Older = 4;
+			public const int Sha256 = 5;
+			public const int Hash256 = 6;
+			public const int Ripemd160 = 7;
+			public const int Hash160 = 8;
+			public const int And = 9;
+			public const int Or = 10;
+			public const int Threshold = 11;
+		}
+
+		private int Tag;
+		private AbstractPolicy(int tag) => Tag = tag;
+
+		public static AbstractPolicy<TPk, TPKh> UnSatisfiable { get; } = new AbstractPolicy<TPk, TPKh>(Tags.Unsatisfiable);
+		public static AbstractPolicy<TPk, TPKh> Trivial { get; } = new AbstractPolicy<TPk, TPKh>(Tags.Trivial);
+
+		internal class KeyHash : AbstractPolicy<TPk, TPKh>
+		{
+			internal TPKh Item;
+			internal KeyHash(TPKh item) : base(Tags.KeyHash)
+			{
+				Item = item;
+			}
+		}
+
+		internal class After : AbstractPolicy<TPk, TPKh>
+		{
+			internal uint Item;
+
+			public After(uint item) : base (Tags.After)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Older : AbstractPolicy<TPk, TPKh>
+		{
+			internal uint Item;
+
+			public Older(uint item) : base (Tags.Older)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Sha256 : AbstractPolicy<TPk, TPKh>
+		{
+			internal uint256 Item;
+
+			public Sha256(uint256 item) :base(Tags.Sha256)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Hash256 : AbstractPolicy<TPk, TPKh>
+		{
+			internal uint256 Item;
+
+			public Hash256(uint256 item) :base(Tags.Hash256)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Ripemd160 : AbstractPolicy<TPk, TPKh>
+		{
+			internal uint160 Item;
+
+			public Ripemd160(uint160 item) :base(Tags.Ripemd160)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Hash160 : AbstractPolicy<TPk, TPKh>
+		{
+			internal uint160 Item;
+
+			public Hash160(uint160 item) :base(Tags.Hash160)
+			{
+				Item = item;
+			}
+		}
+
+		internal class And : AbstractPolicy<TPk, TPKh>
+		{
+			internal List<AbstractPolicy<TPk, TPKh>> Item;
+
+			public And(List<AbstractPolicy<TPk, TPKh>> item) : base(Tags.And)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Or : AbstractPolicy<TPk, TPKh>
+		{
+			internal List<AbstractPolicy<TPk, TPKh>> Item;
+
+			public Or(List<AbstractPolicy<TPk, TPKh>> item) : base(Tags.Or)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Threshold : AbstractPolicy<TPk, TPKh>
+		{
+			internal uint Item1;
+			internal List<AbstractPolicy<TPk, TPKh>> Item2;
+
+			public Threshold(uint item1, List<AbstractPolicy<TPk, TPKh>> item2) : base (Tags.Threshold)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+
+		public static AbstractPolicy<TPk, TPKh> NewUnsatisfiable() => UnSatisfiable;
+		public static AbstractPolicy<TPk, TPKh> NewTrivial() => Trivial;
+		public static AbstractPolicy<TPk, TPKh> NewKeyHash(TPKh item) => new KeyHash(item);
+		public static AbstractPolicy<TPk, TPKh> NewAfter(uint item) => new After(item);
+		public static AbstractPolicy<TPk, TPKh> NewOlder(uint item) => new Older(item);
+		public static AbstractPolicy<TPk, TPKh> NewSha256(uint256 item) => new Sha256(item);
+		public static AbstractPolicy<TPk, TPKh> NewHash256(uint256 item) => new Hash256(item);
+		public static AbstractPolicy<TPk, TPKh> NewRipemd160(uint160 item) => new Ripemd160(item);
+		public static AbstractPolicy<TPk, TPKh> NewHash160(uint160 item) => new Hash160(item);
+		public static AbstractPolicy<TPk, TPKh> NewAnd(IEnumerable<AbstractPolicy<TPk, TPKh>> item) => new And(item.ToList());
+		public static AbstractPolicy<TPk, TPKh> NewOr(IEnumerable<AbstractPolicy<TPk, TPKh>> item) => new Or(item.ToList());
+		public static AbstractPolicy<TPk, TPKh> NewThreshold(uint item1, IEnumerable<AbstractPolicy<TPk, TPKh>> item2) => new Threshold(item1, item2.ToList());
+
+		#endregion
+
+		#region Equatable members
+
+		public override int GetHashCode()
+		{
+			switch (Tag)
+			{
+				case Tags.Unsatisfiable: return Tags.Unsatisfiable;
+				case Tags.Trivial: return Tags.Trivial;
+			}
+
+			int num = 0;
+			switch (this)
+			{
+				case KeyHash self:
+				{
+					num = Tags.KeyHash;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				}
+				case After self:
+					num = Tags.After;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Older self:
+					num = Tags.Older;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Sha256 self:
+					num = Tags.Sha256;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Hash256 self:
+					num = Tags.Hash256;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Ripemd160 self:
+					num = Tags.Ripemd160;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Hash160 self:
+					num = Tags.Hash160;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case And self:
+					num = Tags.And;
+					foreach (var subPolicy in self.Item)
+					{
+						num = -1640531527 + subPolicy.GetHashCode() + ((num << 6) + (num >> 2));
+					}
+					return num;
+				case Or self:
+					num = Tags.Or;
+					foreach (var subPolicy in self.Item)
+					{
+						num = -1640531527 + subPolicy.GetHashCode() + ((num << 6) + (num >> 2));
+					}
+					return num;
+				case Threshold self:
+					num = Tags.Threshold;
+					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
+					foreach (var subPolicy in self.Item2)
+					{
+						num = -1640531527 + subPolicy.GetHashCode() + ((num << 6) + (num >> 2));
+					}
+
+					return num;
+			}
+
+			throw new Exception("Unreachable!");
+		}
+
+
+		public bool Equals(AbstractPolicy<TPk, TPKh> other)
+		{
+			if (other == null)
+				return false;
+			if (this.Tag != other.Tag)
+				return false;
+			switch (this.Tag)
+			{
+				case (Tags.Unsatisfiable): return true;
+				case (Tags.Trivial): return true;
+			}
+			switch (this)
+			{
+				case KeyHash self:
+					return self.Item.Equals(((KeyHash) other).Item);
+				case After self:
+					return self.Item.Equals(((After)other).Item);
+				case Older self:
+					return self.Item.Equals(((Older)other).Item);
+				case Sha256 self:
+					return self.Item.Equals(((Sha256)other).Item);
+				case Hash256 self:
+					return self.Item.Equals(((Hash256)other).Item);
+				case Ripemd160 self:
+					return self.Item.Equals(((Ripemd160)other).Item);
+				case Hash160 self:
+					return self.Item.Equals(((Hash160)other).Item);
+				case And self:
+					var andSet = new HashSet<AbstractPolicy<TPk, TPKh>>(self.Item);
+					return andSet.SetEquals(((And)other).Item);
+				case Or self:
+					var orSet = new HashSet<AbstractPolicy<TPk, TPKh>>(self.Item);
+					return orSet.SetEquals(((Or)other).Item);
+				case Threshold self:
+					var subSet = new HashSet<AbstractPolicy<TPk, TPKh>>(self.Item2);
+					var o = (Threshold) other;
+					return (self.Item1 == o.Item1) && (subSet.SetEquals(o.Item2));
+			}
+			throw new Exception("Unreachable!");
+		}
+
+		#endregion
+
+		public static AbstractPolicy<TPk, TPKh> FromTree(Tree top)
+		{
+			var n = top.Name;
+			var l = top.Args.Count;
+			if (n == "UNSATISFIABLE" && l == 0)
+				return UnSatisfiable;
+			if (n == "TRIVIAL" && l == 0)
+				return Trivial;
+			if (n == "pkh" && l == 1)
+				return Tree.Terminal(top.Args[0], pk => NewKeyHash(MiniscriptFragmentParser<TPk, TPKh>.ParseHash(pk)));
+			if (n == "after" && l == 1)
+				return Tree.Terminal(top.Args[0], x => NewAfter(UInt32.Parse(x)));
+			if (n == "older" && l == 1)
+				return Tree.Terminal(top.Args[0], x => NewOlder(UInt32.Parse(x)));
+			if (n == "sha256" && l == 1)
+				return Tree.Terminal(top.Args[0], x => NewSha256(uint256.Parse(x)));
+			if (n == "hash256" && l == 1)
+				return Tree.Terminal(top.Args[0], x => NewHash256(uint256.Parse(x)));
+			if (n == "ripemd160" && l == 1)
+				return Tree.Terminal(top.Args[0], x => NewRipemd160(uint160.Parse(x)));
+			if (n == "hash160" && l == 1)
+				return Tree.Terminal(top.Args[0], x => NewHash160(uint160.Parse(x)));
+			if (n == "and")
+			{
+				if (!top.Args.Any())
+					throw new ParsingException("and without args");
+				var subsAnd = top.Args.Select(FromTree);
+				return NewAnd(subsAnd);
+			}
+			if (n == "or")
+			{
+				if (!top.Args.Any())
+					throw new ParsingException("and without args");
+				var subsAnd = top.Args.Select(FromTree);
+				return NewOr(subsAnd);
+			}
+
+			if (n == "thresh")
+			{
+				if (!top.Args[0].Args.Any())
+					throw new ParsingException($"Unexpected {top.Args[0].Args[0].Name}");
+				var thresh = UInt32.Parse(top.Args[0].Name);
+				if (thresh >= l)
+					throw new ParsingException(
+						$"number of sub policy in threshold ({l}), exceeded k ({top.Args[0].Name})");
+				return NewThreshold(thresh, top.Args.Skip(1).Select(FromTree));
+			}
+
+			throw new ParsingException($"Unexpected {n}. with {l} argument");
+		}
+
+		/// <summary>
+		/// Flatten out trees of `And`s and `Or`s; eliminate `Trivial` and
+		/// `Unsatisfiable`'s Does not reorder any branches; use `.sort`
+		/// </summary>
+		/// <returns></returns>
+		public AbstractPolicy<TPk, TPKh> Normalize()
+		{
+			switch (this)
+			{
+				case And self:
+					var retSubsAnd = new List<AbstractPolicy<TPk, TPKh>>();
+					foreach (var sub in self.Item)
+					{
+						var s = sub.Normalize();
+						if (s == Trivial)
+						{
+						}
+						else if (s == UnSatisfiable)
+						{
+							return UnSatisfiable;
+						}
+						else if (s is And subAnd)
+						{
+							retSubsAnd.AddRange(subAnd.Item);
+						}
+						else
+						{
+							retSubsAnd.Add(s);
+						}
+					}
+
+					if (retSubsAnd.Count == 0)
+						return Trivial;
+					else if (retSubsAnd.Count == 1)
+						return retSubsAnd.First();
+					else
+						return NewAnd(retSubsAnd);
+
+				case Or self:
+					var retSubsOr = new List<AbstractPolicy<TPk, TPKh>>();
+					foreach (var sub in self.Item)
+					{
+						if (sub == Trivial) return Trivial;
+						else if (sub == UnSatisfiable) {}
+						else if (sub is Or orSub) retSubsOr.AddRange(orSub.Item);
+						else retSubsOr.Add(sub);
+					}
+
+					if (retSubsOr.Count == 0) return Trivial;
+					else if (retSubsOr.Count == 1) return retSubsOr.First();
+					else return NewOr(retSubsOr);
+			}
+
+			return this;
+		}
+
+		public override string ToString()
+			=> ToStringCore(new StringBuilder()).ToString();
+
+		private StringBuilder ToStringCore(StringBuilder sb)
+		{
+			switch (this.Tag)
+			{
+				case Tags.Unsatisfiable: return sb.Append("UNSATISFIABLE");
+				case Tags.Trivial: return sb.Append("TRIVIAL");
+			}
+			switch (this)
+			{
+				case KeyHash self:
+					return sb.AppendFormat("pkh({0})", self.Item.ToHex());
+				case After self:
+					return sb.AppendFormat("after({0})", self.Item);
+				case Older self:
+					return sb.AppendFormat("older({0})", self.Item);
+				case Sha256 self:
+					return sb.AppendFormat("sha256({0})", self.Item);
+				case Hash256 self:
+					return sb.AppendFormat("hash256({0})", self.Item);
+				case Ripemd160 self:
+					return sb.AppendFormat("ripemd160({0})", self.Item);
+				case Hash160 self:
+					return sb.AppendFormat("hash160({0})", self.Item);
+				case And self:
+					sb.Append("and(");
+					if (self.Item.Any())
+					{
+						self.Item[0].ToStringCore(sb);
+						foreach (var sub in self.Item.Skip(1))
+						{
+							sb.Append(",");
+							sub.ToStringCore(sb);
+						}
+					}
+					return sb.Append(")");
+				case Or self:
+					sb.Append("or(");
+					if (self.Item.Any())
+					{
+						self.Item[0].ToStringCore(sb);
+						foreach (var sub in self.Item.Skip(1))
+						{
+							sb.Append(",");
+							sub.ToStringCore(sb);
+						}
+					}
+					return sb.Append(")");
+				case Threshold self:
+					sb.AppendFormat("thresh({0}",self.Item1);
+					foreach (var sub in self.Item2)
+					{
+						sb.Append(",");
+						sub.ToStringCore(sb);
+					}
+					return sb.Append(")");
+			}
+			throw new Exception("Unreachable!");
+		}
+
+		public AbstractPolicy<TPk, TPKh> Sort()
+		{
+			switch (this)
+			{
+				case And self:
+					var newSubsAnd = self.Item.Select(x => x.Sort()).ToList();
+					newSubsAnd.Sort();
+					return NewAnd(newSubsAnd);
+				case Or self:
+					var newSubsOr = self.Item.Select(x => x.Sort()).ToList();
+					newSubsOr.Sort();
+					return NewOr(newSubsOr);
+				case Threshold self:
+					var newSubs = self.Item2.Select(x => x.Sort()).ToList();
+					newSubs.Sort();
+					return NewThreshold(self.Item1, newSubs);
+			}
+			return this;
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
new file mode 100644
index 0000000000..d35e7ede8c
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -0,0 +1,1114 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices.ComTypes;
+using NBitcoin.Scripting.Miniscript.Types;
+
+namespace NBitcoin.Scripting.Miniscript.Policy
+{
+	public class CompilerException : Exception
+	{
+		public static CompilerException TopLevelNonSafe =
+			new CompilerException("Top level element of compilation result was not safe");
+		public static CompilerException ImpossibleNonMalleableCompilation =
+			new CompilerException("Top level of compilation result was malleable!");
+
+		public static CompilerException MaxOpCountExceeded =
+			new CompilerException(
+				$"one path in the optimal miniscript has opcodes more than {Constants.MAX_OPS_PER_SCRIPT}. consider using more simple script");
+
+		private CompilerException(string msg) : base(msg) {}
+	}
+
+	/// <summary>
+	/// This represents the state of the best possible compilation
+	/// of a given policy(implicitly keyed).
+	/// </summary>
+	internal class CompilationKey : IEquatable<CompilationKey>
+	{
+		/// <summary>
+		/// The type of the compilation result
+		/// </summary>
+		internal readonly MiniscriptFragmentType Type;
+
+		/// <summary>
+		/// Whether the result cannot be easily converted into verify form.
+		/// This is exactly the opposite of has_verify_from in the data-types.
+		/// This is required in cases where it is important to distinguish between
+		/// two Compilation of the same-type: one of which is expensive to verify and
+		/// the other is not.
+		/// </summary>
+		internal readonly bool ExpensiveVerify;
+		/// <summary>
+		/// The probability of dissatisfaction of the compilation of the policy.
+		/// Note that all possible compilations of a (sub)policy have the same sat-prob
+		/// and only differ in DissatProb.
+		/// </summary>
+		internal readonly double? DissatProb;
+
+		public bool IsSubtype(CompilationKey other) =>
+			Type.IsSubtype(other.Type) &&
+			ExpensiveVerify == other.ExpensiveVerify &&
+			DissatProb == other.DissatProb;
+
+		internal CompilationKey(MiniscriptFragmentType type, bool expensiveVerify, double? dissatProb)
+		{
+			Type = type;
+			DissatProb = dissatProb;
+			ExpensiveVerify = expensiveVerify;
+		}
+
+		public override bool Equals(object obj) => Equals(obj as CompilationKey);
+
+		public bool Equals(CompilationKey other)
+			=>
+			!(other is null) &&
+				(Type.Equals(other.Type) && DissatProb == other.DissatProb && ExpensiveVerify == other.ExpensiveVerify);
+
+		public override int GetHashCode()
+		{
+			int num = 0;
+			num = -1640531527 + Type.GetHashCode() + ((num << 6) + (num >> 2));
+			num = -1640531527 + DissatProb.GetHashCode() + ((num << 6) + (num >> 2));
+			num = -1640531527 + ExpensiveVerify.GetHashCode() + ((num << 6) + (num >> 2));
+			return num;
+		}
+	}
+
+	internal class CompilerExtData : IProperty<CompilerExtData>
+	{
+		/// <summary>
+		/// If this node is the direct child of a disjunction, this field must have
+		/// the probability of its branch being taken. Otherwise it is ignored.
+		/// All functions initialize it to `None` .
+		/// </summary>
+		internal double? BranchProb;
+
+		/// <summary>
+		/// The number of bytes needed to satisfy the fragment in segwit format
+		/// (total length of all witness pushes, plus their own length prefixes)
+		/// </summary>
+		internal readonly double SatisfyCost;
+		internal readonly double? DissatCost;
+
+		public CompilerExtData(double? branchProb, double satisfyCost, double? dissatCost)
+		{
+			BranchProb = branchProb;
+			SatisfyCost = satisfyCost;
+			DissatCost = dissatCost;
+		}
+
+		public CompilerExtData() {}
+
+		public override CompilerExtData FromTrue()
+		{
+			// only used in casts. should never be computed directly
+			throw new Exception("Unreachable");
+		}
+
+		public override CompilerExtData FromFalse() =>
+			new CompilerExtData(
+				null,
+				double.MaxValue,
+				0.0
+				);
+
+		public override CompilerExtData FromPk() =>
+			new CompilerExtData(
+				null,
+				73.0,
+				1.0
+				);
+
+		public override CompilerExtData FromPkH() =>
+			new CompilerExtData(null, 73.0 + 34.0, 1.0 + 34.0);
+
+		public override CompilerExtData FromMulti(int k, int pkLength) =>
+			new CompilerExtData(null, 1.0 + 73.0 * k, (1.0 * (k + 1)));
+
+		public override CompilerExtData FromHash()
+			=> new CompilerExtData(null, 33.0, 33.0);
+
+		public override CompilerExtData FromTime(uint time) =>
+			new CompilerExtData(null, 0.0, null);
+
+		public override bool TryCastAlt(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, DissatCost);
+			return true;
+		}
+
+		public override bool TryCastSwap(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, DissatCost);
+			return true;
+		}
+
+		public override bool TryCastCheck(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, DissatCost);
+			return true;
+		}
+
+		public override bool TryCastDupIf(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, 2.0 + SatisfyCost, 1.0);
+			return true;
+		}
+
+		public override bool TryCastVerify(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, null);
+			return true;
+		}
+
+		public override bool TryCastNonZero(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, 1.0);
+			return true;
+		}
+
+		public override bool TryCastZeroNotEqual(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, DissatCost);
+			return true;
+		}
+
+		public override bool TryCastTrue(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, null);
+			return true;
+		}
+
+		public override bool TryCastOrIFalse(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, null);
+			return true;
+		}
+
+		public override bool TryCastUnLikely(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, 2.0 + SatisfyCost, 1.0);
+			return true;
+		}
+
+		public override bool TryCastLikely(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, 1.0 + SatisfyCost, 2.0);
+			return true;
+		}
+
+		public override bool TryAndB(CompilerExtData l, CompilerExtData r, out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, l.SatisfyCost + r.SatisfyCost,
+				l.DissatCost + r.DissatCost
+			);
+			return true;
+		}
+
+		public override bool TryAndV(CompilerExtData l, CompilerExtData r, out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, l.SatisfyCost + r.SatisfyCost, null);
+			return true;
+		}
+
+		public override bool TryOrB(CompilerExtData left, CompilerExtData right, out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			var lProb = left.BranchProb.Value; // left branch prob must always be set for disjunctions
+			var rProb = right.BranchProb.Value; // and for right branch.
+			result = new CompilerExtData(
+				null,
+				lProb * (left.SatisfyCost + right.DissatCost.Value) + rProb * (right.SatisfyCost + left.DissatCost.Value),
+				left.DissatCost + right.DissatCost
+				);
+			return true;
+		}
+
+		public override bool TryOrD(CompilerExtData left, CompilerExtData right, out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			var lProb = left.BranchProb.Value; // left branch prob must always be set for disjunctions
+			var rProb = right.BranchProb.Value; // and for right branch.
+			result = new CompilerExtData(
+				null,
+				(lProb * left.SatisfyCost + rProb * (right.SatisfyCost + left.DissatCost.Value)),
+				right.DissatCost + left.DissatCost.Value
+				);
+			return true;
+		}
+
+		public override bool TryOrC(CompilerExtData left, CompilerExtData right, out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			var lProb = left.BranchProb.Value; // left branch prob must always be set for disjunctions
+			var rProb = right.BranchProb.Value; // and for right branch.
+			result = new CompilerExtData(
+				null,
+				lProb * (left.SatisfyCost) +
+				rProb * (right.SatisfyCost + left.DissatCost.Value),
+				null
+			);
+			return true;
+		}
+
+		public override bool TryOrI(CompilerExtData left, CompilerExtData right, out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			var lProb = left.BranchProb.Value; // left branch prob must always be set for disjunctions
+			var rProb = right.BranchProb.Value; // and for right branch.
+			result = new CompilerExtData(
+				null,
+				lProb * (2.0 + left.SatisfyCost) + rProb * (1.0 + right.SatisfyCost),
+				new[] {(2.0 + left.DissatCost), (1.0 + right.DissatCost)}.Min()
+				);
+			return true;
+		}
+
+		public override bool TryAndOr(CompilerExtData a, CompilerExtData b, CompilerExtData c, out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			if (!a.DissatCost.HasValue) throw FragmentPropertyException.LeftNotDissatisfiable();
+			var aProb = a.BranchProb.Value;
+			var bProb = b.BranchProb.Value;
+			var cProb = c.BranchProb.Value;
+			var aDis = a.DissatCost.Value;
+			result = new CompilerExtData(
+				null,
+				aProb * (a.SatisfyCost + b.SatisfyCost)
+				+ cProb * (aDis + c.SatisfyCost),
+				aDis + c.DissatCost
+				);
+			return true;
+		}
+
+		public override bool TryAndN(CompilerExtData l, CompilerExtData r, out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, l.SatisfyCost + r.SatisfyCost, l.DissatCost);
+			return true;
+		}
+
+		public override bool TryThreshold(int k, int n, SubCk ck, out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			var kOverN = k;
+			var satisfyCost = 0.0;
+			var dissatisfyCost = 0.0;
+			for (int i = 0; i < n; i++)
+			{
+				if (!ck(i, out var sub, error))
+					return false;
+				satisfyCost += sub.SatisfyCost;
+				dissatisfyCost += sub.DissatCost.Value;
+			}
+
+			result = new CompilerExtData(
+				null,
+				satisfyCost * kOverN + dissatisfyCost * (1.0 - kOverN),
+				dissatisfyCost);
+			return true;
+		}
+	}
+
+	internal class AstElemExt<TPk, TPKh>
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
+	{
+		internal readonly Miniscript<TPk, TPKh> Ms;
+		internal readonly CompilerExtData CompExtData;
+
+		public AstElemExt(CompilerExtData compilerExtData, Miniscript<TPk, TPKh> ms)
+		{
+			CompExtData = compilerExtData;
+			Ms = ms;
+		}
+
+		/// <summary>
+		/// Compute a one dimensional cost, given a probability of satisfaction and
+		/// a probability of dissatisfaction. if `dissatProb` is `null` then it is
+		/// assumed that dissatisfaction never occurs
+		/// </summary>
+		/// <param name="satProb"></param>
+		/// <param name="dissatProb"></param>
+		/// <returns></returns>
+		internal double Cost1d(double satProb, double? dissatProb)
+		{
+			var dissatCost = 0.0;
+			if (dissatProb.HasValue && CompExtData.DissatCost.HasValue)
+				dissatCost = dissatProb.Value * CompExtData.DissatCost.Value;
+			else if (dissatProb.HasValue && !CompExtData.DissatCost.HasValue)
+				dissatCost = double.PositiveInfinity;
+			return
+				Ms.Ext.PkCost +
+				(CompExtData.SatisfyCost * satProb) +
+				dissatCost;
+
+		}
+
+		internal static AstElemExt<TPk, TPKh> Terminal(Terminal<TPk, TPKh> ast)
+		{
+			if (Property<CompilerExtData, TPk, TPKh>.TypeCheck(ast, out var compExtData, new List<FragmentPropertyException>()))
+				return new AstElemExt<TPk, TPKh>(compExtData, Miniscript<TPk, TPKh>.FromAst(ast));
+			throw new Exception("Unreachable!");
+		}
+
+		internal static  bool TryConstructBinary(
+			Terminal<TPk, TPKh> ast,
+			AstElemExt<TPk, TPKh> l,
+			AstElemExt<TPk, TPKh> r,
+			out AstElemExt<TPk, TPKh> result,
+			List<FragmentPropertyException> errors)
+		{
+			result = null;
+			Func<int, CompilerExtData> lookupExt =
+				(int n) => n == 0 ? l.CompExtData : n == 1 ? r.CompExtData : throw new Exception("Unreachable");
+			if (Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(ast, out var ty, errors)
+			    && Property<ExtData, TPk, TPKh>.TypeCheck(ast, out var ext, errors)
+			    && Property<CompilerExtData, TPk, TPKh>.TryTypeCheck(ast, lookupExt, out var compExtdata, errors))
+			{
+				result = new AstElemExt<TPk, TPKh>(compExtdata, new Miniscript<TPk, TPKh>(ty, ast, ext));
+				return true;
+			}
+			return false;
+		}
+
+		internal static bool TryConstructTernary(
+			Terminal<TPk, TPKh> ast,
+			AstElemExt<TPk, TPKh> a,
+			AstElemExt<TPk, TPKh> b,
+			AstElemExt<TPk, TPKh> c,
+			out AstElemExt<TPk, TPKh> result,
+			List<FragmentPropertyException> errors)
+		{
+			result = null;
+			Func<int, CompilerExtData> lookupExt =
+				n =>
+					n == 0 ? a.CompExtData :
+					n == 1 ? b.CompExtData :
+					n == 2 ? c.CompExtData :
+					throw new Exception("Unreachable");
+
+			if (Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(ast, out var ty, errors)
+			    && Property<ExtData, TPk, TPKh>.TypeCheck(ast, out var ext, errors)
+			    && Property<CompilerExtData, TPk, TPKh>.TryTypeCheck(ast, lookupExt, out var compExtdata, errors))
+			{
+				result = new AstElemExt<TPk, TPKh>(compExtdata, new Miniscript<TPk, TPKh>(ty, ast, ext));
+				return true;
+			}
+			return false;
+		}
+		public List<AstElemExt<TPk, TPKh>> GetAllCasts()
+		{
+			var ast = this;
+			var casts = new List<AstElemExt<TPk, TPKh>>();
+			var errors = new List<FragmentPropertyException>();
+			if (ast.Ms.Ext.TryCastCheck(out var resExtCheck, errors)
+			    && ast.Ms.Type.TryCastCheck(out var resTypeCheck, errors)
+			    && ast.CompExtData.TryCastCheck(out var resCompExtCheck, errors)
+			    )
+			{
+				var castC =
+					new AstElemExt<TPk, TPKh>(
+						resCompExtCheck,
+						new Miniscript<TPk,TPKh>(resTypeCheck, Terminal<TPk, TPKh>.NewCheck(ast.Ms), resExtCheck)
+					);
+				casts.Add(castC);
+			}
+			if (ast.Ms.Ext.TryCastDupIf(out var resExtD, errors)
+			    && ast.Ms.Type.TryCastDupIf(out var resTypeD, errors)
+			    && ast.CompExtData.TryCastDupIf(out var resCompExtD, errors)
+			    )
+			{
+				var castD =
+					new AstElemExt<TPk, TPKh>(
+						resCompExtD,
+						new Miniscript<TPk,TPKh>(resTypeD, Terminal<TPk, TPKh>.NewDupIf(ast.Ms), resExtD)
+					);
+				casts.Add(castD);
+			}
+			if (ast.Ms.Ext.TryCastLikely(out var resExtLikely, errors)
+			    && ast.Ms.Type.TryCastLikely(out var resTypeLikely, errors)
+			    && ast.CompExtData.TryCastLikely(out var resCompExtLikely, errors)
+			    )
+			{
+				var castLikely =
+					new AstElemExt<TPk, TPKh>(
+						resCompExtLikely,
+						new Miniscript<TPk,TPKh>(
+							resTypeLikely,
+							Terminal<TPk, TPKh>.NewOrI(Miniscript<TPk, TPKh>.FromAst(Terminal<TPk, TPKh>.False), ast.Ms),
+							resExtLikely)
+					);
+				casts.Add(castLikely);
+			}
+			if (ast.Ms.Ext.TryCastUnLikely(out var resExtUnLikely, errors)
+			    && ast.Ms.Type.TryCastUnLikely(out var resTypeUnLikely, errors)
+			    && ast.CompExtData.TryCastUnLikely(out var resCompExtUnLikely, errors)
+			    )
+			{
+				var castUnLikely =
+					new AstElemExt<TPk, TPKh>(
+						resCompExtUnLikely,
+						new Miniscript<TPk,TPKh>(
+							resTypeUnLikely,
+							Terminal<TPk, TPKh>.NewOrI(ast.Ms, Miniscript<TPk, TPKh>.FromAst(Terminal<TPk, TPKh>.False)),
+							resExtUnLikely)
+					);
+				casts.Add(castUnLikely);
+			}
+			if (ast.Ms.Ext.TryCastVerify(out var resExtV, errors)
+			    && ast.Ms.Type.TryCastVerify(out var resTypeV, errors)
+			    && ast.CompExtData.TryCastVerify(out var resCompExtV, errors)
+			    )
+			{
+				var castV =
+					new AstElemExt<TPk, TPKh>(
+						resCompExtV,
+						new Miniscript<TPk,TPKh>(
+							resTypeV,
+							Terminal<TPk, TPKh>.NewVerify(ast.Ms),
+							resExtV)
+					);
+				casts.Add(castV);
+			}
+			if (ast.Ms.Ext.TryCastNonZero(out var resExtJ, errors)
+			    && ast.Ms.Type.TryCastNonZero(out var resTypeJ, errors)
+			    && ast.CompExtData.TryCastNonZero(out var resCompExtJ, errors)
+			    )
+			{
+				var castJ =
+					new AstElemExt<TPk, TPKh>(
+						resCompExtJ,
+						new Miniscript<TPk,TPKh>(
+							resTypeJ,
+							Terminal<TPk, TPKh>.NewNonZero(ast.Ms),
+							resExtJ)
+					);
+				casts.Add(castJ);
+			}
+			if (ast.Ms.Ext.TryCastTrue(out var resExtTrue, errors)
+			    && ast.Ms.Type.TryCastTrue(out var resTypeTrue, errors)
+			    && ast.CompExtData.TryCastTrue(out var resCompExtTrue, errors)
+			    )
+			{
+				var castTrue =
+					new AstElemExt<TPk, TPKh>(
+						resCompExtTrue,
+						new Miniscript<TPk,TPKh>(
+							resTypeTrue,
+							Terminal<TPk, TPKh>.NewAndV(ast.Ms, Miniscript<TPk, TPKh>.FromAst(Terminal<TPk, TPKh>.NewTrue())),
+							resExtTrue)
+					);
+				casts.Add(castTrue);
+			}
+			if (ast.Ms.Ext.TryCastSwap(out var resExtS, errors)
+			    && ast.Ms.Type.TryCastSwap(out var resTypeS, errors)
+			    && ast.CompExtData.TryCastSwap(out var resCompExtS, errors)
+			    )
+			{
+				var castS =
+					new AstElemExt<TPk, TPKh>(
+						resCompExtS,
+						new Miniscript<TPk, TPKh>(
+							resTypeS,
+							Terminal<TPk, TPKh>.NewSwap(ast.Ms),
+							resExtS)
+					);
+				casts.Add(castS);
+			}
+			if (ast.Ms.Ext.TryCastAlt(out var resExtA, errors)
+			    && ast.Ms.Type.TryCastAlt(out var resTypeA, errors)
+			    && ast.CompExtData.TryCastAlt(out var resCompExtA, errors)
+			    )
+			{
+				var castA =
+					new AstElemExt<TPk, TPKh>(
+						resCompExtA,
+						new Miniscript<TPk,TPKh>(
+							resTypeA,
+							Terminal<TPk, TPKh>.NewAlt(ast.Ms),
+							resExtA)
+					);
+				casts.Add(castA);
+			}
+			if (ast.Ms.Ext.TryCastZeroNotEqual(out var resExtN, errors)
+			    && ast.Ms.Type.TryCastZeroNotEqual(out var resTypeN, errors)
+			    && ast.CompExtData.TryCastZeroNotEqual(out var resCompExtN, errors)
+			    )
+			{
+				var castN =
+					new AstElemExt<TPk, TPKh>(
+						resCompExtN,
+						new Miniscript<TPk,TPKh>(
+							resTypeN,
+							Terminal<TPk, TPKh>.NewZeroNotEqual(ast.Ms),
+							resExtN)
+					);
+				casts.Add(castN);
+			}
+			return casts;
+		}
+	}
+
+	public static class Compiler<TPk, TPKh>
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
+	{
+		private static bool InsertElem(
+			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> map,
+			AstElemExt<TPk, TPKh> astElemExt,
+			double satProb,
+			double? dissatProb
+		)
+		{
+			if (!astElemExt.Ms.Type.Malleability.NonMalleable)
+				return false;
+
+			if (astElemExt.Ms.Ext.OpsCountSat > Constants.MAX_OPS_PER_SCRIPT)
+				return false;
+
+			var elemCost = astElemExt.Cost1d(satProb, dissatProb);
+			var elemKey = new CompilationKey(astElemExt.Ms.Type, astElemExt.Ms.Ext.HasVerifyForm, dissatProb);
+
+			// Check whether the new element is worse than any existing element. If there
+			// is an element which is a subtype of the current element and has better cost,
+			// don't consier this element.
+			var isWorse = map.Select((kv) =>
+			{
+				var existingElementCost = kv.Value.Cost1d(satProb, dissatProb);
+				return kv.Key.IsSubtype(elemKey) && existingElementCost <= elemCost;
+			}).Aggregate(false, (acc, x) => acc || x);
+			if (!isWorse)
+			{
+				// if the element is not worse any element in the map, remove elements
+				// whose subtype is the current element and have worse cost.
+				var keysToRemove = map.Where(kv =>
+				{
+					var existingElementsCost = kv.Value.Cost1d(satProb, dissatProb);
+					return (elemKey.IsSubtype(kv.Key) && existingElementsCost >= elemCost);
+				}).Select(kv => kv.Key).ToList();
+				foreach (var k in keysToRemove)
+					map.Remove(k);
+				map.AddOrReplace(elemKey, astElemExt);
+			}
+
+			return !isWorse;
+		}
+
+		/// <summary>
+		/// Insert the cast-closure of in the `astElemExt`. The castStack
+		/// has all the elements whose closure is yet to inserted in the map.
+		/// A cast-closure refers to trying all possible casts on a particular element
+		/// if they are better than the current elements in the global map
+		///
+		/// At the start and end of this function, we maintain that the invariant that
+		/// all map is smallest possible closure of all compilation of a policy with
+		/// given sat and dissat probabilities.
+		/// </summary>
+		/// <param name="map"></param>
+		/// <param name="astElemExt"></param>
+		/// <param name="satProb"></param>
+		/// <param name="dissatProb"></param>
+		/// <exception cref="NotImplementedException"></exception>
+		private static void InsertElemClosure(
+			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> map,
+			AstElemExt<TPk, TPKh> astElemExt,
+			double satProb,
+			double? dissatProb
+		)
+		{
+			var castStack = new Queue<AstElemExt<TPk, TPKh>>();
+			if (InsertElem(map, astElemExt, satProb, dissatProb))
+				castStack.Enqueue(astElemExt);
+
+			while (castStack.Count != 0)
+			{
+				var casts = castStack.Dequeue().GetAllCasts();
+				foreach (var newExt in casts)
+				{
+					if (InsertElem(map, newExt, satProb, dissatProb))
+						castStack.Enqueue(newExt);
+				}
+			}
+		}
+
+		/// <summary>
+		/// Insert the best wrapped compilations of a particular Terminal. If the
+		/// dissat probability is None, then we directly get the closure of the element.
+		/// Otherwise, some wrappers require the compilation of the policy with dissat
+		/// `null` because they convert it into a dissat around it.
+		/// For example, `l` wrapper should it argument it dissat. `null` because it can
+		/// always dissatisfy the policy outside and it find the better inner compilation
+		/// given that it may be not be necessary to dissatisfy. For these elements, we
+		/// apply the wrappers around the element once and bring them into the same
+		/// dissat probability map and get their closure.
+		/// </summary>
+		/// <param name="policyCache"></param>
+		/// <param name="policy"></param>
+		/// <param name="map"></param>
+		/// <param name="data"></param>
+		/// <param name="satProb"></param>
+		/// <param name="dissatProb"></param>
+		private static void InsertBestWrapped(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+				policyCache,
+			ConcretePolicy<TPk, TPKh> policy,
+			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> map,
+			AstElemExt<TPk, TPKh> data,
+			double satProb,
+			double? dissatProb
+		)
+		{
+			InsertElemClosure(map, data, satProb, dissatProb);
+
+			if (dissatProb.HasValue)
+			{
+				foreach (var x in BestCompilations(policyCache, policy, satProb, null).Values)
+				{
+					var casts = x.GetAllCasts();
+					foreach (var newExt in casts) {
+						InsertElemClosure(map, newExt, satProb, dissatProb);
+					}
+				}
+			}
+		}
+
+		/// <summary>
+		/// Get the best compilations of a policy with a given sat and dissat probabilities. This functions
+		/// caches the results into a global policy cache.
+		/// </summary>
+		/// <param name="policyCache"></param>
+		/// <param name="policy"></param>
+		/// <param name="satProb"></param>
+		/// <param name="dissatProb"></param>
+		/// <returns></returns>
+		private static IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> BestCompilations(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+				policyCache,
+			ConcretePolicy<TPk, TPKh> policy,
+			double satProb,
+			double? dissatProb
+		)
+		{
+			if (policyCache.TryGetValue(Tuple.Create(policy, satProb, dissatProb), out var result))
+				return result;
+			var ret = new Dictionary<CompilationKey, AstElemExt<TPk, TPKh>>();
+
+			// ---- define helpers ----
+			Action<AstElemExt<TPk, TPKh>> insertWrap = (x) =>
+				InsertBestWrapped(policyCache, policy, ret, x, satProb, dissatProb);
+
+			Action<
+					IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>,
+					IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>,
+					Tuple<double, double>,
+					Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>>>
+				compileBinary = (l, right, w, f) =>
+					CompileBinary(policyCache, policy, ret,  l, right, w, satProb, dissatProb, f);
+
+			Action<
+					IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>,
+					IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>,
+					IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>,
+					Tuple<double, double>
+				>
+				compileTernary = (a, b, c, w) =>
+					CompileTernary(policyCache, policy, ret, a, b, c, w, satProb, dissatProb);
+			// -------
+
+			switch (policy)
+			{
+				case ConcretePolicy<TPk, TPKh>.Key pol:
+					insertWrap(AstElemExt<TPk, TPKh>.Terminal(Terminal<TPk, TPKh>.NewPkH(pol.Item.ToPubKeyHash())));
+					insertWrap(AstElemExt<TPk, TPKh>.Terminal(Terminal<TPk, TPKh>.NewPk(pol.Item)));
+					break;
+				case ConcretePolicy<TPk, TPKh>.After pol:
+					insertWrap(AstElemExt<TPk, TPKh>.Terminal(Terminal<TPk, TPKh>.NewAfter(pol.Item)));
+					break;
+				case ConcretePolicy<TPk, TPKh>.Older pol:
+					insertWrap(AstElemExt<TPk, TPKh>.Terminal(Terminal<TPk, TPKh>.NewOlder(pol.Item)));
+					break;
+				case ConcretePolicy<TPk, TPKh>.Sha256 pol:
+					insertWrap(AstElemExt<TPk, TPKh>.Terminal(Terminal<TPk, TPKh>.NewSha256(pol.Item)));
+					break;
+				case ConcretePolicy<TPk, TPKh>.Hash256 pol:
+					insertWrap(AstElemExt<TPk, TPKh>.Terminal(Terminal<TPk, TPKh>.NewHash256(pol.Item)));
+					break;
+				case ConcretePolicy<TPk, TPKh>.Ripemd160 pol:
+					insertWrap(AstElemExt<TPk, TPKh>.Terminal(Terminal<TPk, TPKh>.NewRipemd160(pol.Item)));
+					break;
+				case ConcretePolicy<TPk, TPKh>.Hash160 pol:
+					insertWrap(AstElemExt<TPk, TPKh>.Terminal(Terminal<TPk, TPKh>.NewHash160(pol.Item)));
+					break;
+				case ConcretePolicy<TPk, TPKh>.And pol:
+					Debug.Assert(pol.Item.Count == 2);
+					var l = BestCompilations(policyCache, pol.Item[0], satProb, dissatProb);
+					var r = BestCompilations(policyCache, pol.Item[1], satProb, dissatProb);
+					var q_zero_l = BestCompilations(policyCache, pol.Item[0], satProb, null);
+					var q_zero_r = BestCompilations(policyCache, pol.Item[1], satProb, null);
+					compileBinary(l, r, Tuple.Create(1.0, 1.0), Terminal<TPk, TPKh>.NewAndB);
+					compileBinary(r, l, Tuple.Create(1.0, 1.0), Terminal<TPk, TPKh>.NewAndB);
+					compileBinary(l, r, Tuple.Create(1.0, 1.0), Terminal<TPk, TPKh>.NewAndV);
+					compileBinary(r, l, Tuple.Create(1.0, 1.0), Terminal<TPk, TPKh>.NewAndV);
+					var zeroComp = new Dictionary<CompilationKey, AstElemExt<TPk, TPKh>>();
+					zeroComp.Add(
+						new CompilationKey(
+							new MiniscriptFragmentType().FromFalse(),
+							new ExtData().FromFalse().HasVerifyForm,
+							dissatProb
+							),
+						AstElemExt<TPk, TPKh>.Terminal(Terminal<TPk, TPKh>.NewFalse())
+						);
+					compileTernary(l, q_zero_r, zeroComp, Tuple.Create(1.0, 0.0));
+					compileTernary(r, q_zero_l, zeroComp, Tuple.Create(1.0, 0.0));
+					break;
+				case ConcretePolicy<TPk, TPKh>.Or pol:
+					var total = (double) (pol.Item[0].Item1 + pol.Item[1].Item1);
+					var lw = pol.Item[0].Item1 / total;
+					var rw = pol.Item[1].Item1 / total;
+					if (pol.Item[0].Item2 is ConcretePolicy<TPk, TPKh>.And a)
+					{
+						var a1 =
+							BestCompilations(
+								policyCache,
+								a.Item[0],
+								lw * satProb,
+								(dissatProb ?? 0.0) + rw * satProb);
+						var a2 =
+							BestCompilations(
+								policyCache,
+								a.Item[0],
+								lw * satProb, null);
+						var b1 =
+							BestCompilations(
+								policyCache,
+								a.Item[1],
+								lw * satProb,
+								(dissatProb ?? 0) + rw * satProb
+								);
+						var b2 =
+							BestCompilations(
+								policyCache,
+								a.Item[1],
+								lw * satProb,
+								null
+								);
+						var c = BestCompilations(policyCache, pol.Item[1].Item2, rw * satProb, dissatProb);
+						compileTernary(a1, b2, c, Tuple.Create(lw, rw));
+						compileTernary(b1, a2, c, Tuple.Create(lw, rw));
+					}
+
+					if (pol.Item[1].Item2 is ConcretePolicy<TPk, TPKh>.And x)
+					{
+						var a1 = BestCompilations(policyCache, x.Item[0], rw * satProb, (dissatProb ?? 0.0) + lw * satProb);
+						var a2 = BestCompilations(policyCache, x.Item[0], rw * satProb, null);
+						var b1 = BestCompilations(policyCache, x.Item[1], rw * satProb, (dissatProb ?? 0.0) + lw * satProb);
+						var b2 = BestCompilations(policyCache, x.Item[1], rw * satProb, null);
+						var c = BestCompilations(policyCache, pol.Item[0].Item2, lw * satProb, dissatProb);
+						compileTernary(a1, b2, c, Tuple.Create(rw, lw));
+						compileTernary(b1, a2, c, Tuple.Create(rw, lw));
+					}
+
+					Func<double, List<double?>> dissatProbs =
+						(w) =>
+						{
+							var dissatSet = new List<double?>();
+							dissatSet.Add((dissatProb ?? 0.0) + w * satProb);
+							dissatSet.Add(w * satProb);
+							dissatSet.Add(dissatProb);
+							dissatSet.Add(null);
+							return dissatSet;
+						};
+
+					var lComp = new List<IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>();
+					var rComp = new List<IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>();
+					foreach (var dissatProbRight in dissatProbs(rw))
+						lComp.Add(BestCompilations(policyCache, pol.Item[0].Item2, lw * satProb, dissatProbRight));
+					foreach (var dissatProbLeft in dissatProbs(lw))
+						rComp.Add(BestCompilations(policyCache, pol.Item[1].Item2, rw * satProb, dissatProbLeft));
+					compileBinary(lComp[0], rComp[0], Tuple.Create(lw, rw), Terminal<TPk, TPKh>.NewOrB);
+					compileBinary(rComp[0], lComp[0], Tuple.Create(rw, lw), Terminal<TPk, TPKh>.NewOrB);
+
+					compileBinary(lComp[0], rComp[2], Tuple.Create<double, double>(lw, rw), Terminal<TPk, TPKh>.NewOrD);
+					compileBinary(rComp[0], lComp[2], Tuple.Create<double, double>(rw, lw), Terminal<TPk, TPKh>.NewOrD);
+
+					compileBinary(lComp[1], rComp[3], Tuple.Create(lw, rw), Terminal<TPk, TPKh>.NewOrC);
+					compileBinary(rComp[1], lComp[3], Tuple.Create(rw, lw), Terminal<TPk, TPKh>.NewOrC);
+
+					compileBinary(lComp[2], rComp[3], Tuple.Create(lw, rw), Terminal<TPk, TPKh>.NewOrI);
+					compileBinary(rComp[2], lComp[3], Tuple.Create(rw, lw), Terminal<TPk, TPKh>.NewOrI);
+
+					compileBinary(lComp[3], rComp[2], Tuple.Create(lw, rw), Terminal<TPk, TPKh>.NewOrI);
+					compileBinary(rComp[3], lComp[2], Tuple.Create(rw, lw), Terminal<TPk, TPKh>.NewOrI);
+					break;
+
+				case ConcretePolicy<TPk, TPKh>.Threshold pol:
+					var n = pol.Item2.Count;
+					var kOverN = ((double) pol.Item1) / n;
+					var subAst = new List<Miniscript<TPk, TPKh>>();
+					var subExtData  = new List<CompilerExtData>();
+					var bestEs = new List<Tuple<CompilerExtData, AstElemExt<TPk, TPKh>>>();
+					var bestWs = new List<Tuple<CompilerExtData, AstElemExt<TPk, TPKh>>>();
+
+					var minValue = new { Item1 = 0, Item2 = double.PositiveInfinity };
+
+					for (int i = 0; i < pol.Item2.Count; i++)
+					{
+						var ast = pol.Item2[i];
+						var sp = satProb * kOverN;
+						var dp = (dissatProb ?? 0.0) + (1.0 - kOverN) * satProb;
+						var be = BestE(policyCache, ast, sp, dp);
+						var bw = BestW(policyCache, ast, sp, dp);
+						var diff = be.Cost1d(sp, dp) - bw.Cost1d(sp, dp);
+						bestEs.Add(Tuple.Create(be.CompExtData, be));
+						bestWs.Add(Tuple.Create(bw.CompExtData, bw));
+						if (diff < minValue.Item2)
+							minValue = new {Item1 = i, Item2 = diff};
+					}
+					subExtData.Add(bestEs[minValue.Item1].Item1);
+					subAst.Add(bestEs[minValue.Item1].Item2.Ms);
+					for (int j = 0; j < pol.Item2.Count; j++)
+					{
+						if (j != minValue.Item1)
+						{
+							subExtData.Add(bestWs[j].Item1);
+							subAst.Add(bestWs[j].Item2.Ms);
+						}
+					}
+
+					var astResult = Terminal<TPk, TPKh>.NewThresh(pol.Item1, subAst);
+					IProperty<CompilerExtData>.SubCk subCk =
+						(int i, out CompilerExtData data, List<FragmentPropertyException> errors) =>
+						{
+							data = subExtData[i];
+							return true;
+						};
+					if (new CompilerExtData().TryThreshold((int) pol.Item1, n, subCk,
+						out var newThresh, new List<FragmentPropertyException>()))
+					{
+						var astExtResult = new AstElemExt<TPk, TPKh>(
+								newThresh,
+								Miniscript<TPk, TPKh>.FromAst(astResult));
+						insertWrap(astExtResult);
+					}
+					else
+					{
+						throw new Exception("Bug: Failed to create CompilerExtData from sub expression we have just compiled");
+					}
+					var keyVec =
+						pol.Item2
+							.Select(s => (s is ConcretePolicy<TPk, TPKh>.Key pk) ? pk.Item : null)
+							.Where(pk => pk != null)
+							.ToList();
+					if (keyVec.Count == pol.Item2.Count && pol.Item2.Count <= 20)
+						insertWrap(AstElemExt<TPk, TPKh>.Terminal(Terminal<TPk, TPKh>.NewThreshM(pol.Item1, keyVec)));
+					break;
+				default:
+					throw new Exception("Unreachable!");
+			}
+
+			foreach (var k in ret.Keys)
+				Debug.Assert(k.DissatProb == dissatProb);
+
+			Console.WriteLine($"finished best-compilations for {policy}");
+			var costs = ret.Values.Select(x => Tuple.Create(x.Cost1d(satProb, dissatProb), x.Ms)).ToList();
+			costs.Sort((x, y) => x.Item1.CompareTo(y.Item1));
+			foreach (var cost in costs)
+				Console.WriteLine($"{cost.Item1} ::: {cost.Item2}");
+			Console.WriteLine("");
+
+			if (ret.Count == 0)
+				// The only reason we are discarding elements out of compiler is because
+				// compilations exceed opcount or are non-malleable. If there is no possible
+				// compilations for any policies regardless of dissat probability then it must
+				// have all compilations exceeded the Max opcount because we already checked
+				// that policy must have non-malleable compilations before calling this compile function
+				throw CompilerException.MaxOpCountExceeded;
+			policyCache.Add(Tuple.Create(policy, satProb, dissatProb), ret);
+			return ret;
+		}
+		/// <summary>
+		/// Helper function to compile different types of binary fragments.
+		/// `sat_prob` and `dissat_prob` represent the sat and dissat probabilities
+		/// of root or. `weights` represents the odds for taking each sub branch.
+		/// </summary>
+		/// <param name="policyCache"></param>
+		/// <param name="policy"></param>
+		/// <param name="ret"></param>
+		/// <param name="leftComp"></param>
+		/// <param name="rightComp"></param>
+		/// <param name="weights"></param>
+		/// <param name="satProb"></param>
+		/// <param name="dissatProb"></param>
+		/// <param name="binFunc"></param>
+		/// <exception cref="NotImplementedException"></exception>
+
+		private static void CompileBinary(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+				policyCache,
+			ConcretePolicy<TPk, TPKh> policy,
+			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> ret,
+			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> leftComp,
+			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> rightComp,
+			Tuple<double, double> weights,
+			double satProb,
+			double? dissatProb,
+			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> binFunc
+		)
+		{
+			var errors = new List<FragmentPropertyException>();
+			foreach (var l in leftComp.Values)
+			{
+				foreach (var r in rightComp.Values)
+				{
+					var ast = binFunc(l.Ms, r.Ms);
+					l.CompExtData.BranchProb = weights.Item1;
+					r.CompExtData.BranchProb = weights.Item2;
+					if (AstElemExt<TPk, TPKh>.TryConstructBinary(ast, l, r, out var newExt, errors))
+						InsertBestWrapped(policyCache, policy, ret, newExt, satProb, dissatProb);
+				}
+			}
+		}
+
+		private static void CompileTernary(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+				policyCache,
+			ConcretePolicy<TPk, TPKh> policy,
+			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> ret,
+			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> aComp,
+			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> bComp,
+			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> cComp,
+			Tuple<double, double> weights,
+			double satProb,
+			double? dissatProb
+			)
+		{
+			var errors = new List<FragmentPropertyException>();
+			foreach (var a in aComp.Values)
+			{
+				foreach (var b in bComp.Values)
+				{
+					foreach (var c in cComp.Values)
+					{
+						a.CompExtData.BranchProb = weights.Item1;
+						b.CompExtData.BranchProb = weights.Item1;
+						c.CompExtData.BranchProb = weights.Item2;
+						var ast = Terminal<TPk, TPKh>.NewAndOr(a.Ms, b.Ms, c.Ms);
+						if (AstElemExt<TPk, TPKh>.TryConstructTernary(ast, a, b, c, out var newExt, errors))
+							InsertBestWrapped(policyCache, policy, ret, newExt, satProb, dissatProb);
+					}
+				}
+			}
+		}
+
+		public static Miniscript<TPk, TPKh> BestCompilation(ConcretePolicy<TPk, TPKh> policy)
+		{
+			var policyCache =
+				new Dictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>();
+			var x = BestT(policyCache, policy, 1.0, null).Ms;
+			if (!x.Type.Malleability.Safe)
+				throw CompilerException.TopLevelNonSafe;
+			if (!x.Type.Malleability.NonMalleable)
+				throw CompilerException.ImpossibleNonMalleableCompilation;
+
+			return x;
+		}
+
+		/// <summary>
+		/// Obtain the best B expression with given sat and dissat.
+		/// </summary>
+		/// <param name="policyCache"></param>
+		/// <param name="policy"></param>
+		/// <param name="satProb"></param>
+		/// <param name="dissatProb"></param>
+		/// <returns></returns>
+		/// <exception cref="NotImplementedException"></exception>
+		internal static AstElemExt<TPk, TPKh> BestT(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+				policyCache,
+			ConcretePolicy<TPk, TPKh> policy,
+			double satProb,
+			double? dissatProb
+			)
+		{
+			var result =
+				BestCompilations(policyCache, policy, satProb, dissatProb)
+					.Where(kv => kv.Key.Type.Correctness.Base == Base.B && kv.Key.DissatProb == dissatProb)
+					.Select(kv => kv.Value);
+
+			if (!result.Any())
+				throw CompilerException.MaxOpCountExceeded;
+			return result.Aggregate( // get where the cost is minimum
+				(champion, challenger) =>
+				{
+					 var challengerValue = challenger.Cost1d(satProb, dissatProb);
+					 var championValue = champion.Cost1d(satProb, dissatProb);
+					 return (challengerValue < championValue) ? challenger : champion;
+				});
+		}
+
+		/// <summary>
+		/// Obtain the B.deu with the given sat and dissat.
+		/// </summary>
+		/// <param name="policyCache"></param>
+		/// <param name="policy"></param>
+		/// <param name="satProb"></param>
+		/// <param name="dissatProb"></param>
+		/// <returns></returns>
+		/// <exception cref="NotImplementedException"></exception>
+		private static AstElemExt<TPk, TPKh> BestE(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+				policyCache,
+				ConcretePolicy<TPk, TPKh> policy,
+				double satProb,
+				double? dissatProb
+			)
+		{
+			var result =
+				BestCompilations(policyCache, policy, satProb, dissatProb)
+					.Where(kv =>
+						kv.Key.Type.Correctness.Base == Base.B
+						&& kv.Key.Type.Correctness.Unit
+						&& kv.Value.Ms.Type.Malleability.Dissat == Dissat.Unique
+						&& kv.Key.DissatProb == dissatProb);
+
+			if (!result.Any())
+				throw CompilerException.MaxOpCountExceeded;
+			return result.Select(kv => kv.Value)
+				.Aggregate( // get where cost is minimum
+					(champion, challenger) =>
+						{
+							var challengerValue = challenger.Cost1d(satProb, dissatProb);
+							var championValue = champion.Cost1d(satProb, dissatProb);
+							return (challengerValue < championValue) ? challenger : champion;
+						}
+					);
+		}
+
+		internal static AstElemExt<TPk, TPKh> BestW(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+				policyCache,
+				ConcretePolicy<TPk, TPKh> policy,
+				double satProb,
+				double? dissatProb
+			)
+		{
+			var result =
+				BestCompilations(policyCache, policy, satProb, dissatProb)
+					.Where(kv =>
+						kv.Key.Type.Correctness.Base == Base.W
+						&& kv.Key.Type.Correctness.Unit
+						&& kv.Value.Ms.Type.Malleability.Dissat == Dissat.Unique
+						&& kv.Key.DissatProb == dissatProb
+					);
+			if (!result.Any())
+				throw CompilerException.MaxOpCountExceeded;
+			return result.Select(kv => kv.Value)
+				.Aggregate( // get where cost is minimum
+					(champion, challenger) =>
+						{
+							var challengerValue = challenger.Cost1d(satProb, dissatProb);
+							var championValue = champion.Cost1d(satProb, dissatProb);
+							return (challengerValue < championValue) ? challenger : champion;
+						}
+					);
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
new file mode 100644
index 0000000000..38927ba2b6
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
@@ -0,0 +1,567 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NBitcoin.Scripting.Parser;
+
+namespace NBitcoin.Scripting.Miniscript.Policy
+{
+	public enum PolicyError
+	{
+		/// <summary>
+		/// `And` fragments only support two args
+		/// </summary>
+		NonBinaryArgAnd,
+		/// <summary>
+		/// `Or` fragments only support two args
+		/// </summary>
+		NonBinaryArgOr,
+
+		/// <summary>
+		/// `Thresh` fragment can only have `1 <= k <= n`
+		/// </summary>
+		IncorrectThresh,
+
+		/// <summary>
+		/// `older` or `after` fragment can only have `n = 0`
+		/// </summary>
+		ZeroTime,
+
+		/// <summary>
+		/// `after` fragment can only have `n < 2^31`
+		/// </summary>
+		TimeTooFar
+	}
+	public class ConcretePolicy<TPk, TPKh> : IEquatable<ConcretePolicy<TPk, TPKh>>, ILiftable<TPk, TPKh>
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
+	{
+		#region Subtype definitions
+
+
+		private static class Tags
+		{
+			internal const int Key = 0;
+			internal const int After = 1;
+			internal const int Older = 2;
+			internal const int Sha256 = 3;
+			internal const int Hash256 = 4;
+			internal const int Ripemd160 = 5;
+			internal const int Hash160 = 6;
+			internal const int And = 7;
+			internal const int Or = 8;
+			internal const int Threshold = 9;
+		}
+
+		private int Tag { get; }
+
+		private ConcretePolicy(int tag) => Tag = tag;
+
+		internal class Key : ConcretePolicy<TPk, TPKh>
+		{
+			public TPk Item;
+			public Key(TPk item) : base(Tags.Key) => Item = item;
+		}
+
+		internal class After : ConcretePolicy<TPk, TPKh>
+		{
+			public uint Item;
+
+			public After(uint item) : base(Tags.After) => Item = item;
+		}
+
+		internal class Older : ConcretePolicy<TPk, TPKh>
+		{
+			public uint Item;
+
+			public Older(uint item) : base(Tags.Older) => Item = item;
+		}
+
+		internal class Sha256 : ConcretePolicy<TPk, TPKh>
+		{
+			public uint256 Item;
+
+			public Sha256(uint256 item) : base(Tags.Sha256) => Item = item;
+		}
+
+		internal class Hash256 : ConcretePolicy<TPk, TPKh>
+		{
+			public uint256 Item;
+
+			public Hash256(uint256 item) : base(Tags.Hash256) => Item = item;
+		}
+
+		internal class Ripemd160 : ConcretePolicy<TPk, TPKh>
+		{
+			public uint160 Item;
+
+			public Ripemd160(uint160 item) : base(Tags.Ripemd160) => Item = item;
+		}
+
+		internal class Hash160 : ConcretePolicy<TPk, TPKh>
+		{
+			public uint160 Item;
+			public Hash160(uint160 item) : base(Tags.Hash160) => Item = item;
+		}
+
+		internal class And : ConcretePolicy<TPk, TPKh>
+		{
+			public List<ConcretePolicy<TPk, TPKh>> Item;
+
+			public And(List<ConcretePolicy<TPk, TPKh>> item) : base(Tags.And)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Or : ConcretePolicy<TPk, TPKh>
+		{
+			public List<Tuple<uint, ConcretePolicy<TPk, TPKh>>> Item;
+
+			public Or(List<Tuple<uint, ConcretePolicy<TPk, TPKh>>> item) : base(Tags.Or)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Threshold : ConcretePolicy<TPk, TPKh>
+		{
+			public uint Item1;
+			public List<ConcretePolicy<TPk, TPKh>> Item2;
+
+			public Threshold(uint item1, List<ConcretePolicy<TPk, TPKh>> item2) : base(Tags.Threshold)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+
+		public static ConcretePolicy<TPk, TPKh> NewKey(TPk pk) => new Key(pk);
+		public static ConcretePolicy<TPk, TPKh> NewAfter(uint time) => new After(time);
+		public static ConcretePolicy<TPk, TPKh> NewOlder(uint item) => new Older(item);
+		public static ConcretePolicy<TPk, TPKh> NewSha256(uint256 item) => new Sha256(item);
+		public static ConcretePolicy<TPk, TPKh> NewHash256(uint256 item) => new Hash256(item);
+		public static ConcretePolicy<TPk, TPKh> NewRipemd160(uint160 item) => new Ripemd160(item);
+		public static ConcretePolicy<TPk, TPKh> NewHash160(uint160 item) => new Hash160(item);
+		public static ConcretePolicy<TPk, TPKh> NewAnd(IEnumerable<ConcretePolicy<TPk, TPKh>> subs) => new And(subs.ToList());
+		public static ConcretePolicy<TPk, TPKh> NewOr(IEnumerable<Tuple<uint, ConcretePolicy<TPk, TPKh>>> item) => new Or(item.ToList());
+		public static ConcretePolicy<TPk, TPKh> NewThreshold(uint k, IEnumerable<ConcretePolicy<TPk, TPKh>> subs) => new Threshold(k, subs.ToList());
+
+		#endregion
+
+
+		#region Equatable members
+
+		public bool Equals(ConcretePolicy<TPk, TPKh> other)
+		{
+			if (other == null || this.Tag != other.Tag)
+				return false;
+			switch (this)
+			{
+				case Key self:
+					return self.Item.Equals(((Key)other).Item);
+				case After self:
+					return self.Item.Equals(((After)other).Item);
+				case Older self:
+					return self.Item.Equals(((Older) other).Item);
+				case Sha256 self:
+					return self.Item.Equals(((Sha256) other).Item);
+				case Hash256 self:
+					return self.Item.Equals(((Hash256) other).Item);
+				case Ripemd160 self:
+					return self.Item.Equals(((Ripemd160) other).Item);
+				case Hash160 self:
+					return self.Item.Equals(((Hash160) other).Item);
+				case And self:
+					return self.Item.SequenceEqual(((And)other).Item);
+				case Or self:
+					return self.Item.SequenceEqual(((Or)other).Item);
+				case Threshold self:
+					var thres = (Threshold) other;
+					return self.Item1 == thres.Item1 && self.Item2.SequenceEqual(thres.Item2);
+			}
+			throw new Exception("Unreachable!");
+		}
+
+		public override int GetHashCode()
+		{
+			int num = 0;
+			switch (this)
+			{
+				case Key self:
+					num = Tags.Key;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case After self:
+					num = Tags.After;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Older self:
+					num = Tags.Older;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Sha256 self:
+					num = Tags.Sha256;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Hash256 self:
+					num = Tags.Hash256;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Ripemd160 self:
+					num = Tags.Ripemd160;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Hash160 self:
+					num = Tags.Hash160;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case And self:
+					num = Tags.And;
+					foreach (var a in self.Item)
+					{
+						num = -1640531527 + a.GetHashCode() + ((num << 6) + (num >> 2));
+					}
+					return num;
+				case Or self:
+					num = Tags.Or;
+					foreach (var a in self.Item)
+					{
+						num = -1640531527 + a.Item1.GetHashCode() + ((num << 6) + (num >> 2));
+						num = -1640531527 + a.Item2.GetHashCode() + ((num << 6) + (num >> 2));
+					}
+					return num;
+				case Threshold self:
+					num = Tags.Threshold;
+					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
+					foreach (var policy in self.Item2)
+					{
+						num = -1640531527 + policy.GetHashCode() + ((num << 6) + (num >> 2));
+					}
+
+					return num;
+			}
+			throw new Exception("Unreachable!");
+		}
+
+		public override bool Equals(object obj) =>
+			Equals(obj as ConcretePolicy<TPk, TPKh>);
+
+		#endregion
+
+
+		public AbstractPolicy<TPk, TPKh> Lift()
+		{
+			AbstractPolicy<TPk, TPKh> res = null;
+			switch (this)
+			{
+				case Key self:
+					res = AbstractPolicy<TPk, TPKh>.NewKeyHash(self.Item.ToPubKeyHash());
+					break;
+				case After self:
+					res = AbstractPolicy<TPk, TPKh>.NewAfter(self.Item);
+					break;
+				case Older self:
+					res = AbstractPolicy<TPk, TPKh>.NewOlder(self.Item);
+					break;
+				case Sha256 self:
+					res = AbstractPolicy<TPk, TPKh>.NewSha256(self.Item);
+					break;
+				case Hash256 self:
+					res = AbstractPolicy<TPk, TPKh>.NewHash256(self.Item);
+					break;
+				case Ripemd160 self:
+					res = AbstractPolicy<TPk, TPKh>.NewRipemd160(self.Item);
+					break;
+				case Hash160 self:
+					res = AbstractPolicy<TPk, TPKh>.NewHash160(self.Item);
+					break;
+				case And self:
+					res = AbstractPolicy<TPk, TPKh>.NewAnd(self.Item.Select(sub => sub.Lift()).ToList());
+					break;
+				case Or self:
+					res = AbstractPolicy<TPk, TPKh>.NewOr(self.Item.Select(sub => sub.Item2.Lift()).ToList());
+					break;
+				case Threshold self:
+					res = AbstractPolicy<TPk, TPKh>.NewThreshold(self.Item1, self.Item2.Select(sub => sub.Lift()).ToList());
+					break;
+			}
+
+			return res.Normalize();
+
+		}
+
+		# region to/from string
+		public override string ToString() =>
+			ToStringCore(new StringBuilder()).ToString();
+
+		private StringBuilder ToStringCore(StringBuilder sb)
+		{
+			switch (this)
+			{
+				case Key self:
+					return sb.Append($"pk({self.Item.ToHex()})");
+				case After self:
+					return sb.Append($"after({self.Item.ToString()})");
+				case Older self:
+					return sb.Append($"older({self.Item.ToString()})");
+				case Sha256 self:
+					return sb.Append($"sha256({self.Item})");
+				case Hash256 self:
+					return sb.Append($"hash256({self.Item})");
+				case Ripemd160 self:
+					return sb.Append($"ripemd160({self.Item})");
+				case Hash160 self:
+					return sb.Append($"hash160({self.Item})");
+				case And self:
+					sb.Append("and(");
+					if (self.Item.Count != 0)
+					{
+						self.Item[0].ToStringCore(sb);
+						foreach (var sub in self.Item.Skip(1))
+						{
+							sb.Append(",");
+							sub.ToStringCore(sb);
+						}
+					}
+					return sb.Append(")");
+				case Or self:
+					sb.Append("or(");
+					if (self.Item.Count != 0)
+					{
+						sb.Append(self.Item[0].Item1.ToString());
+						sb.Append("@");
+						self.Item[0].Item2.ToStringCore(sb);
+						foreach (var sub in self.Item.Skip(1))
+						{
+							sb.Append(",");
+							sb.Append(sub.Item1.ToString());
+							sb.Append("@");
+							sub.Item2.ToStringCore(sb);
+						}
+					}
+					return sb.Append(")");
+				case Threshold self:
+					sb.Append($"thresh({self.Item1.ToString()}");
+					foreach (var sub in self.Item2)
+					{
+						sb.Append(",");
+						sub.ToStringCore(sb);
+					}
+
+					return sb.Append(")");
+			}
+			throw new Exception("Unreachable!");
+		}
+
+		public static ConcretePolicy<TPk, TPKh> Parse(string str)
+			=> FromTree(Tree.Parse(str));
+
+		/// <summary>
+		/// Instantiate policy from Tree.
+		/// </summary>
+		/// <param name="t"></param>
+		/// <returns></returns>
+		private static ConcretePolicy<TPk, TPKh> FromTree(Tree t)
+			=> FromTreeProb(t, false).Item2;
+
+		/// <summary>
+		/// Helper for FromTree which takes into account if we are able to hold `@` in or expression.
+		/// </summary>
+		/// <param name="top"></param>
+		/// <param name="allowProb">If the top level expression is `or` it is not allowed to be prefixed with `@`
+		/// otherwise it is allowed to.</param>
+		/// <returns></returns>
+		/// <exception cref="ParsingException"></exception>
+		/// <exception cref="NotImplementedException"></exception>
+		private static Tuple<uint, ConcretePolicy<TPk, TPKh>> FromTreeProb(Tree top, bool allowProb)
+		{
+			uint fragProb = 1;
+			string fragName = String.Empty;
+			var nameSplit = top.Name.Split('@');
+			if (nameSplit.Length == 1)
+			{
+				fragName = nameSplit[0];
+			}
+			else if (nameSplit.Length == 2)
+			{
+				if (!allowProb)
+					throw new ParsingException("we found @ in the context not allowed to.");
+				fragProb = UInt32.Parse(nameSplit[0]);
+				fragName = nameSplit[1];
+			}
+			else
+			{
+				throw new ParsingException("We found more than one @ in expression");
+			}
+
+			ConcretePolicy<TPk, TPKh> res = null;
+			switch (fragName)
+			{
+				case "pk":
+					if (top.Args.Count == 1)
+						res = Tree.Terminal(top.Args[0], pk => NewKey(MiniscriptFragmentParser<TPk, TPKh>.ParseKey(pk)));
+					break;
+				case "after":
+					if (top.Args.Count == 1)
+						res = Tree.Terminal(top.Args[0], x => NewAfter(UInt32.Parse(x)));
+					break;
+				case "older":
+					if (top.Args.Count == 1)
+						res = Tree.Terminal(top.Args[0], x => NewOlder(UInt32.Parse(x)));
+					break;
+				case "sha256":
+					if (top.Args.Count == 1)
+						res = Tree.Terminal(top.Args[0], x => NewSha256(uint256.Parse(x)));
+					break;
+				case "hash256":
+					if (top.Args.Count == 1)
+						res = Tree.Terminal(top.Args[0], x => NewHash256(uint256.Parse(x)));
+					break;
+				case "ripemd160":
+					if (top.Args.Count == 1)
+						res = Tree.Terminal(top.Args[0], x => NewRipemd160(uint160.Parse(x)));
+					break;
+				case "hash160":
+					if (top.Args.Count == 1)
+						res = Tree.Terminal(top.Args[0], x => NewHash160(uint160.Parse(x)));
+					break;
+				case "and":
+					if (!top.Args.Any())
+						throw new ParsingException("and without args");
+					var subsAnd = top.Args.Select(FromTree);
+					res = NewAnd(subsAnd);
+					break;
+				case "or":
+					if (!top.Args.Any())
+						throw new ParsingException("or without args");
+					var subsOr = top.Args.Select(x => FromTreeProb(x, true));
+					res = NewOr(subsOr);
+					break;
+				case "thresh":
+					if (!top.Args.Any())
+						throw new ParsingException("thresh without args");
+					if (top.Args[0].Args.Any())
+						throw new ParsingException($"Unexpected {top.Args[0].Args[0].Name}");
+					var thresh = UInt32.Parse(top.Args[0].Name);
+					if (thresh >= top.Args.Count)
+						throw new ParsingException(
+							$"number of sub policy in threshold ({top.Args.Count}), exceeded k ({top.Args[0].Name})");
+					res = NewThreshold(thresh, top.Args.Skip(1).Select(FromTree));
+					break;
+			}
+			if (res is null)
+				throw new ParsingException($"Unexpected {top.Name}");
+			return Tuple.Create(fragProb, res);
+		}
+		# endregion
+
+		/// <summary>
+		/// This returns whether the given policy is valid or not. It maybe possible that the policy
+		/// contains Non-two argument `and`, `or` a `0` arg thresh.
+		/// </summary>
+		/// <returns></returns>
+		/// <exception cref="PolicyException"></exception>
+		public bool AssertValid()
+		{
+			switch (this)
+			{
+				case And self:
+					if (self.Item.Count != 2)
+						throw PolicyException.NonBinaryArgAnd;
+					return self.Item.All(sub => sub.AssertValid());
+				case Or self:
+					if (self.Item.Count != 2)
+						throw PolicyException.IncorrectThresh;
+					return self.Item.All(sub => sub.Item2.AssertValid());
+				case Threshold self:
+					if (self.Item1 <= 0 || self.Item1 > self.Item2.Count)
+						throw PolicyException.IncorrectThresh;
+					return self.Item2.All(sub => sub.AssertValid());
+				case After self:
+					if (self.Item == 0)
+						throw PolicyException.ZeroTime;
+					else if (self.Item > Math.Pow(2u, 31))
+						throw PolicyException.TimeTooFar;
+					return true;
+				case Older self:
+					if (self.Item == 0)
+						throw PolicyException.ZeroTime;
+					else if (self.Item > Math.Pow(2u, 31))
+						throw PolicyException.TimeTooFar;
+					return true;
+
+			}
+
+			return true;
+		}
+
+		/// <summary>
+		/// This returns whether any possible compilation of the policy could be
+		/// compiled as non-malleable and safe. Note that this returns a tuple
+		/// (safe, non-malleable) to avoid because the non-malleability depends on
+		/// safety and we would like to cache results
+		/// </summary>
+		/// <returns></returns>
+		public Tuple<bool, bool> IsSafeNonMalleable()
+		{
+			switch (this)
+			{
+				case Key _ : return Tuple.Create(true, true);
+				case Sha256 _:
+				case Hash256 _:
+				case Ripemd160 _:
+				case Hash160 _:
+				case After _:
+				case Older _:
+					return Tuple.Create(false, true);
+				case Threshold self:
+					var res =
+						self.Item2
+							.Select((sub) => sub.IsSafeNonMalleable())
+							.Aggregate(Tuple.Create(0, 0), (acc, sub) =>
+							{
+								var safeCount = acc.Item1 + (sub.Item1 ? 1: 0);
+								var nonMallCount = acc.Item2 + (sub.Item2 ? 1 : 0);
+								return Tuple.Create(safeCount, nonMallCount);
+							});
+					var hasEnoughSafeSubs = (res.Item1 >= (self.Item2.Count - self.Item1 + 1));
+					var hasEnoughNonMallCount = (res.Item2 == self.Item2.Count && res.Item2 >= (self.Item2.Count - self.Item1));
+					return Tuple.Create(hasEnoughSafeSubs, hasEnoughNonMallCount);
+				case And self:
+					return
+						self.Item
+							.Select(sub => sub.IsSafeNonMalleable())
+							.Aggregate(
+								Tuple.Create(false, true),
+								(acc, x) =>
+								{
+									var l = acc.Item1 || x.Item1; // true if it has at least one safe sub.
+									var r = acc.Item2 && x.Item2; // true if all subs are non malleable
+									return Tuple.Create(l, r);
+								});
+				case Or self:
+					var resOr =
+						self.Item
+							.Select(sub => sub.Item2.IsSafeNonMalleable())
+							.Aggregate(
+								Tuple.Create(true, false, true),
+								(acc, x) =>
+								{
+									var one = acc.Item1 && x.Item1; // all subs are safe
+									var two = acc.Item2 || x.Item1; // at least one is safe
+									var three = acc.Item3 && x.Item2; // all non malleable
+									return Tuple.Create(one, two, three);
+								}
+							);
+					return Tuple.Create(resOr.Item1, resOr.Item2 && resOr.Item3);
+
+			}
+			throw new Exception("Unreachable!");
+		}
+
+		public Miniscript<TPk, TPKh> Compile()
+		{
+			AssertValid();
+			var t = IsSafeNonMalleable();
+			var isSafe = t.Item1;
+			var isNonMalleable = t.Item2;
+			if (!isSafe) throw CompilerException.TopLevelNonSafe;
+			if (!isNonMalleable) throw CompilerException.ImpossibleNonMalleableCompilation;
+			return Compiler<TPk, TPKh>.BestCompilation(this);
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Policy/PolicyException.cs b/NBitcoin/Scripting/Miniscript/Policy/PolicyException.cs
new file mode 100644
index 0000000000..654b9aef4b
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Policy/PolicyException.cs
@@ -0,0 +1,23 @@
+using System;
+
+namespace NBitcoin.Scripting.Miniscript.Policy
+{
+	public class PolicyException : Exception
+	{
+
+		public PolicyException(string msg) : base(msg) {}
+		public PolicyException(string msg, Exception inner) : base(msg, inner) {}
+		public static PolicyException NonBinaryArgAnd =
+			new PolicyException("And policy fragment must take 2 arguments");
+		public static PolicyException NonBinaryArgOr =
+			new PolicyException("Or policy fragment must take 2 arguments");
+
+		public static PolicyException IncorrectThresh =
+			new PolicyException("Threshold k must be greater than 0 and less than n");
+
+		public static PolicyException ZeroTime =
+			new PolicyException("Time must be greater than 0;");
+		public static PolicyException TimeTooFar =
+			new PolicyException("Relative/Absolute time must be less than 2^31");
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Satisfy.cs b/NBitcoin/Scripting/Miniscript/Satisfy.cs
new file mode 100644
index 0000000000..49c7721ae5
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Satisfy.cs
@@ -0,0 +1,175 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	/// <summary>
+	/// Trait describing a lookup table for signatures, hash preimages, etc.
+	/// Every method has a default implementation that simply returns `false`
+	/// on every query. Users are expected to override the methods that they
+	/// have data for.
+	/// </summary>
+	/// <typeparam name="TPk"></typeparam>
+	/// <typeparam name="TPKh"></typeparam>
+	public abstract class ISatisfier<TPk, TPKh>
+	where TPk : IMiniscriptKey<TPKh>
+	where TPKh : IMiniscriptKeyHash
+	{
+		public virtual bool TryGetSignature(TPk pubkey, out TransactionSignature txSig)
+		{
+			txSig = default;
+			return false;
+		}
+		public virtual bool TryGetPubKey(TPKh pubkeyHash, out TPk pubkey)
+		{
+			pubkey = default;
+			return false;
+		}
+		public virtual bool TryGetPubkeyAndSig(TPKh pubkeyHash, out TPk pubkey, out TransactionSignature txSig)
+		{
+			txSig = default;
+			pubkey = default;
+			return false;
+		}
+		public virtual bool TryGetSha256Preimage(uint256 hash, out uint256 preimage)
+		{
+			preimage = default;
+			return false;
+		}
+		public virtual bool TryGetHash256Preimage(uint256 hash, out uint256 preimage)
+		{
+			preimage = default;
+			return false;
+		}
+		public virtual bool TryGetRipemd160Preimage(uint160 hash, out uint256 preimage)
+		{
+			preimage = default;
+			return false;
+		}
+		public virtual bool TryGetHash160Preimage(uint160 hash, out uint256 preimage)
+		{
+			preimage = default;
+			return false;
+		}
+
+		public virtual bool IsOlderThan(uint currentTime) => false;
+		public virtual bool IsAfterThan(uint currentTime) => false;
+	}
+
+	public class InMemorySatisfier<TPk, TPKh> : ISatisfier<TPk, TPKh>, IDictionary<TPk, Tuple<TPk, TransactionSignature>>
+	where TPk : IMiniscriptKey<TPKh>
+	where TPKh : IMiniscriptKeyHash
+	{
+		public override bool TryGetSignature(TPk pubkey, out TransactionSignature txSig)
+		{
+			throw new NotImplementedException();
+		}
+
+		public override bool TryGetPubKey(TPKh pubkeyHash, out TPk pubkey)
+		{
+			throw new NotImplementedException();
+		}
+
+		public override bool TryGetPubkeyAndSig(TPKh pubkeyHash, out TPk pubkey, out TransactionSignature txSig)
+		{
+			throw new NotImplementedException();
+		}
+
+		public override bool TryGetSha256Preimage(uint256 hash, out uint256 preimage)
+		{
+			throw new NotImplementedException();
+		}
+
+		public override bool TryGetHash256Preimage(uint256 hash, out uint256 preimage)
+		{
+			throw new NotImplementedException();
+		}
+
+		public override bool TryGetRipemd160Preimage(uint160 hash, out uint256 preimage)
+		{
+			throw new NotImplementedException();
+		}
+
+		public override bool TryGetHash160Preimage(uint160 hash, out uint256 preimage)
+		{
+			throw new NotImplementedException();
+		}
+
+		public override bool IsOlderThan(uint currentTime)
+		{
+			throw new NotImplementedException();
+		}
+
+		public override bool IsAfterThan(uint currentTime)
+		{
+			throw new NotImplementedException();
+		}
+
+		public IEnumerator<KeyValuePair<TPk, Tuple<TPk, TransactionSignature>>> GetEnumerator()
+		{
+			throw new NotImplementedException();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return GetEnumerator();
+		}
+
+		public void Add(KeyValuePair<TPk, Tuple<TPk, TransactionSignature>> item)
+		{
+			throw new NotImplementedException();
+		}
+
+		public void Clear()
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool Contains(KeyValuePair<TPk, Tuple<TPk, TransactionSignature>> item)
+		{
+			throw new NotImplementedException();
+		}
+
+		public void CopyTo(KeyValuePair<TPk, Tuple<TPk, TransactionSignature>>[] array, int arrayIndex)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool Remove(KeyValuePair<TPk, Tuple<TPk, TransactionSignature>> item)
+		{
+			throw new NotImplementedException();
+		}
+
+		public int Count { get; }
+		public bool IsReadOnly { get; }
+		public void Add(TPk key, Tuple<TPk, TransactionSignature> value)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool ContainsKey(TPk key)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool Remove(TPk key)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool TryGetValue(TPk key, out Tuple<TPk, TransactionSignature> value)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Tuple<TPk, TransactionSignature> this[TPk key]
+		{
+			get => throw new NotImplementedException();
+			set => throw new NotImplementedException();
+		}
+
+		public ICollection<TPk> Keys { get; }
+		public ICollection<Tuple<TPk, TransactionSignature>> Values { get; }
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/ScriptParser.cs b/NBitcoin/Scripting/Miniscript/ScriptParser.cs
new file mode 100644
index 0000000000..798548ff32
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/ScriptParser.cs
@@ -0,0 +1,317 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using NBitcoin.Scripting.Miniscript.Types;
+using NBitcoin.Scripting.Parser;
+
+// When parsing from a script, PubKey is always represented as a "real" PubKey, not by other
+// `IMiniscriptKey` such as HDKey or dummy key.
+// So we constrain generic parameters like this.
+using MS = NBitcoin.Scripting.Miniscript.Miniscript<NBitcoin.PubKey, NBitcoin.uint160>;
+using PM =
+	NBitcoin.Scripting.Parser.Parser<
+		NBitcoin.Scripting.Miniscript.ScriptToken,
+		NBitcoin.Scripting.Miniscript.Miniscript<NBitcoin.PubKey, NBitcoin.uint160>
+	>;
+using Terminal = NBitcoin.Scripting.Miniscript.Terminal<NBitcoin.PubKey, NBitcoin.uint160>;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	internal static class ScriptParser
+	{
+		# region helpers
+		private static PM CheckTerminal(Terminal term)
+			=> i => {
+				var errors = new List<FragmentPropertyException>();
+				if (Property<MiniscriptFragmentType, PubKey, uint160>.TypeCheck(term, out var fragmentType, errors)
+						&& Property<ExtData, PubKey, uint160>.TypeCheck(term, out var extData, errors))
+					return ParserResult<ScriptToken, MS>.Success(i, new MS(fragmentType, term, extData));
+				return ParserResult<ScriptToken, MS>.Failure(i, $"inner type of the miniscript was not valid. ErrorMsg: {errors.Flatten()}");
+
+			};
+
+		# endregion
+		# region leaf
+		private static readonly Parser<ScriptToken, uint> PNumber
+			=
+			from z in Parse.ScriptToken<ScriptToken.Number>()
+			select z.Item;
+
+		private static readonly PM PPubkey
+			=
+			from pk in Parse.ScriptToken<ScriptToken.Pk>()
+			from ms in CheckTerminal(Terminal.NewPk(pk.Item))
+			select ms;
+
+		private static readonly PM PPubkeyHash
+			=
+			from _v in Parse.ScriptToken(ScriptToken.Verify)
+			from e in Parse.ScriptToken(ScriptToken.Equal)
+			from hash20 in Parse.ScriptToken<ScriptToken.Hash20>()
+			from _hash160 in Parse.ScriptToken(ScriptToken.Hash160)
+			from _dup in Parse.ScriptToken(ScriptToken.Dup)
+			from ms in CheckTerminal(Terminal.NewPkH(hash20.Item))
+			select ms;
+
+		private static readonly PM PCheckSig
+			=
+			from _c in Parse.ScriptToken(ScriptToken.CheckSig)
+			from sub in Parse.Ref(() => PExpr)
+			from ms in CheckTerminal(Terminal.NewCheck(sub))
+			select ms;
+
+		private static PM POlder
+			=
+			from _t in Parse.ScriptToken(ScriptToken.CheckSequenceVerify)
+			from x in PNumber
+			from ms in CheckTerminal(Terminal.NewOlder(x))
+			select ms;
+
+		private static PM PAfter
+			=
+				from _t in Parse.ScriptToken(ScriptToken.CheckLocktimeVerify)
+				from x in PNumber
+				from ms in CheckTerminal(Terminal.NewAfter(x))
+				select ms;
+
+		private static Parser<ScriptToken, int> PHashInner
+			=
+			from _sha256 in Parse.ScriptToken(ScriptToken.Verify)
+			from _equal in Parse.ScriptToken(ScriptToken.Equal)
+			from num in PNumber
+			where num == 32u
+			from _s in Parse.ScriptToken(ScriptToken.Size)
+			select 1;
+		private static PM PSha256
+			=
+			from hash in Parse.ScriptToken<ScriptToken.Hash32>()
+			from _hashop in Parse.ScriptToken(ScriptToken.Sha256)
+			from _dummy in PHashInner
+			from ms in CheckTerminal(Terminal.NewSha256(hash.Item))
+			select ms;
+		private static PM PHash256
+			=
+			from hash in Parse.ScriptToken<ScriptToken.Hash32>()
+			from _hashop in Parse.ScriptToken(ScriptToken.Hash256)
+			from _dummy in PHashInner
+			from ms in CheckTerminal(Terminal.NewHash256(hash.Item))
+			select ms;
+		private static PM PRipemd160
+			=
+			from hash in Parse.ScriptToken<ScriptToken.Hash20>()
+			from _hashOp in Parse.ScriptToken(ScriptToken.Ripemd160)
+			from _dummy in PHashInner
+			from ms in CheckTerminal(Terminal.NewRipemd160(hash.Item))
+			select ms;
+		private static PM PHash160
+			=
+			from hash in Parse.ScriptToken<ScriptToken.Hash20>()
+			from _hashOp in Parse.ScriptToken(ScriptToken.Hash160)
+			from _dummy in PHashInner
+			from ms in CheckTerminal(Terminal.NewHash160(hash.Item))
+			select ms;
+		private static PM PHashLocks =
+			PSha256.Or(PHash256).Or(PRipemd160).Or(PHash160);
+
+		private static PM PFalse
+			=
+			from num in PNumber
+			where num == 0u
+			select MS.FromAst(Terminal.NewFalse());
+
+		private static PM PTrue
+			=
+			from num in PNumber
+			where num == 1u
+			select MS.FromAst(Terminal.NewTrue());
+
+		# endregion
+
+		# region unary wrappers
+		private static readonly PM PAlt
+			=
+				from _alt1 in Parse.ScriptToken(ScriptToken.FromAltStack)
+				from expr in Parse.Ref(() => PExpr)
+				from alt in Parse.ScriptToken(ScriptToken.ToAltStack)
+				from ms in  CheckTerminal(Terminal.NewAlt(expr))
+				select ms;
+
+		private static readonly PM PSwap
+			=
+				from expr in Parse.Ref(() => PExpr)
+				from _swap in Parse.ScriptToken(ScriptToken.Swap)
+				from ms in CheckTerminal(Terminal.NewSwap(expr))
+				select ms;
+
+		private static readonly PM PDupIf
+			=
+				from _dupif in Parse.ScriptToken(ScriptToken.EndIf)
+				from v in Parse.Ref(() => PExpr)
+				from _if in Parse.ScriptToken(ScriptToken.If)
+				from _dup in Parse.ScriptToken(ScriptToken.Dup)
+				from ms in CheckTerminal(Terminal.NewDupIf(v))
+				select ms;
+		private static readonly PM PVerify
+			=
+			(
+				from v in Parse.ScriptToken(ScriptToken.Verify)
+				from inner in Parse.Ref(() => PExpr)
+				from ms in CheckTerminal(Terminal.NewVerify(inner))
+				select ms
+			);
+
+		private static readonly PM PNonZero
+			=
+				from _x in Parse.ScriptToken(ScriptToken.EndIf)
+				from inner in Parse.Ref(() => PExpr)
+				from _if in Parse.ScriptToken(ScriptToken.If)
+				from _zeronotequal in Parse.ScriptToken(ScriptToken.ZeroNotEqual)
+				from _size in Parse.ScriptToken(ScriptToken.Size)
+				from ms in CheckTerminal(Terminal.NewNonZero(inner))
+				select ms;
+		private static readonly PM PZeroNotEqual
+			=
+				from _x in Parse.ScriptToken(ScriptToken.ZeroNotEqual)
+				from inner in Parse.Ref(() => PExpr)
+				from ms in CheckTerminal(Terminal.NewZeroNotEqual(inner))
+				select ms;
+
+		# endregion
+
+		# region binary expressions
+		// ------ conjunctions ------
+
+		private static readonly PM PMaybeAndV
+			=
+				from expr1 in
+					Parse.Ref(() =>
+						PExpr
+							.Except(
+								Parse.ScriptToken(ScriptToken.If)
+								.Or(Parse.ScriptToken(ScriptToken.NotIf))
+								.Or(Parse.ScriptToken(ScriptToken.Else))
+								.Or(Parse.ScriptToken(ScriptToken.ToAltStack)))
+					)
+				from expr2 in Parse.Ref(() => PExpr)
+				from ms in CheckTerminal(Terminal.NewAndV(expr2, expr1))
+				select ms;
+
+		private static PM PAndB
+			=
+			from _booland in Parse.ScriptToken(ScriptToken.BoolAnd)
+			from w in Parse.Ref(() => PExpr)
+			from e in Parse.Ref(() => PExpr)
+			from ms in CheckTerminal(Terminal.NewAndB(e, w))
+			select ms;
+		// -----------------------
+
+		// ------ disjunctions ------
+		private static PM POrB
+			=
+			from _e in Parse.ScriptToken(ScriptToken.BoolOr)
+			from inner1 in Parse.Ref(() => PExpr)
+			from _ in Parse.Ref(() => PSwap)
+			from inner2 in Parse.Ref(() => PExpr)
+			from ms in CheckTerminal(Terminal.NewOrB(inner2, inner1))
+			select ms;
+
+		private static PM POrD
+			=
+			from _endif in Parse.ScriptToken(ScriptToken.EndIf)
+			from inner1TOrE in Parse.Ref(() => PExpr)
+			from _notif in Parse.ScriptToken(ScriptToken.NotIf)
+			from _ifdup in Parse.ScriptToken(ScriptToken.IfDup)
+			from inner2E in Parse.Ref(() => PExpr)
+			from ms in CheckTerminal(Terminal.NewOrD(inner2E, inner1TOrE))
+			select ms;
+
+		private static PM POrC
+			=
+			from _endif in Parse.ScriptToken(ScriptToken.EndIf)
+			from inner1v in Parse.Ref(() => PExpr)
+			from _notif in Parse.ScriptToken(ScriptToken.NotIf)
+			from inner2e in Parse.Ref(() => PExpr)
+			from ms in CheckTerminal(Terminal.NewOrC(inner2e, inner1v))
+			select ms;
+
+		private static PM POrI
+			=
+			from _endif in Parse.ScriptToken(ScriptToken.EndIf)
+			from inner1 in Parse.Ref(() => PExpr)
+			from _else in Parse.ScriptToken(ScriptToken.Else)
+			from inner2 in Parse.Ref(() => PExpr)
+			from _if in Parse.ScriptToken(ScriptToken.If)
+			from ms in CheckTerminal(Terminal.NewOrI(inner2, inner1))
+			select ms;
+
+		# endregion
+
+		# region ternary and threshold
+		private static PM PThresh
+			=
+			from _equal in Parse.ScriptToken(ScriptToken.Equal)
+			from k in PNumber
+			from ws in (Parse.ScriptToken(ScriptToken.Add).Then(_ => Parse.Ref(() => PExpr))).AtLeastOnce()
+			from e in Parse.Ref(() => PExpr)
+	 		from ms in CheckTerminal(Terminal.NewThresh(k, ws.Reverse().Concat(new [] { e })))
+			select ms;
+		private static PM PAndOr
+			=
+				from _endif in Parse.ScriptToken(ScriptToken.EndIf)
+				from inner1TOrE in Parse.Ref(() => PExpr)
+				from _else in Parse.ScriptToken(ScriptToken.Else)
+				from inner2 in Parse.Ref(() => PExpr)
+				from _notif in Parse.ScriptToken(ScriptToken.NotIf)
+				from inner3 in Parse.Ref(() => PExpr)
+				select MS.FromAst(Terminal.NewAndOr(inner3, inner2, inner1TOrE));
+
+		private static PM PThreshM
+			=
+			from _ck in Parse.ScriptToken(ScriptToken.CheckMultiSig)
+			from nPubKey in PNumber
+			where nPubKey <= 20u
+			from pks in Parse.ScriptToken<ScriptToken.Pk>().AtLeastOnce()
+			let pksInner = pks.Select(pk => pk.Item).ToList()
+			where pksInner.Count == nPubKey
+			from k in PNumber
+			where k <= pksInner.Count
+			from ms in CheckTerminal(Terminal.NewThreshM(k, pksInner))
+			select ms;
+
+		# endregion
+
+		///<summary>
+		/// Optimize speed by not checking failure case?
+		///</summary>
+		private static readonly PM PExpr =
+			// -------- tree --------
+			PTrue
+				.Or(PFalse)
+				.Or(PPubkey)
+				.Or(PPubkeyHash)
+				.Or(PAfter)
+				.Or(POlder)
+				.Or(PHashLocks)
+				// -------- wrapper -------
+				.Or(PAlt)
+				.Or(PSwap)
+				.Or(PCheckSig)
+				.Or(PDupIf)
+				.Or(PVerify)
+				.Or(PNonZero)
+				.Or(PZeroNotEqual)
+				// --------- conjunctions --------
+				.Or(PMaybeAndV)
+				.Or(PAndB)
+				.Or(PAndOr)
+				// --------- disjunctions --------
+				.Or(POrB)
+				.Or(POrD)
+				.Or(POrC)
+				.Or(POrI)
+				.Or(PThresh)
+				.Or(PThreshM);
+
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/ScriptToken.cs b/NBitcoin/Scripting/Miniscript/ScriptToken.cs
new file mode 100644
index 0000000000..9db97de000
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/ScriptToken.cs
@@ -0,0 +1,464 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection.Emit;
+using System.Runtime.InteropServices;
+using NBitcoin.Scripting.Parser;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	/// <summary>
+	/// Precursor of the actual miniscript fragment when we deserialize from the raw script from the raw script.
+	/// </summary>
+	internal class ScriptToken : IEquatable<ScriptToken>
+	{
+		internal static class Tags
+		{
+			public const int BoolAnd = 0;
+
+			public const int BoolOr = 1;
+
+			public const int Add = 2;
+
+			public const int Equal = 3;
+
+			public const int CheckSig = 4;
+
+			public const int CheckMultiSig = 5;
+
+			public const int CheckSequenceVerify = 6;
+
+			public const int CheckLocktimeVerify = 7;
+
+
+			public const int FromAltStack = 8;
+
+			public const int ToAltStack = 9;
+
+			public const int Drop = 10;
+
+			public const int Dup = 11;
+
+			public const int If = 12;
+
+			public const int IfDup = 13;
+
+			public const int NotIf = 14;
+
+			public const int Else = 15;
+
+			public const int EndIf = 16;
+
+			public const int ZeroNotEqual = 17;
+
+			public const int Size = 18;
+
+			public const int Swap = 19;
+
+			public const int Verify = 20;
+
+			public const int Ripemd160 = 21;
+
+			public const int Hash160 = 22;
+
+			public const int Sha256 = 23;
+
+			public const int Hash256 = 24;
+
+			public const int Number = 25;
+
+			public const int Hash20 = 26;
+
+			public const int Hash32 = 27;
+
+			public const int Pk = 28;
+
+		}
+
+		private ScriptToken(int tag) => Tag = tag;
+
+		internal int Tag { get; }
+
+		public static ScriptToken BoolAnd { get; } = new ScriptToken(Tags.BoolAnd);
+		public static ScriptToken BoolOr { get; } = new ScriptToken(Tags.BoolOr);
+		public static ScriptToken Add { get; } = new ScriptToken(Tags.Add);
+		public static ScriptToken Equal { get; } = new ScriptToken(Tags.Equal);
+		public static ScriptToken CheckSig { get; } = new ScriptToken(Tags.CheckSig);
+		public static ScriptToken CheckMultiSig { get; } = new ScriptToken(Tags.CheckMultiSig);
+		public static ScriptToken CheckSequenceVerify { get; } = new ScriptToken(Tags.CheckSequenceVerify);
+		public static ScriptToken CheckLocktimeVerify { get; } = new ScriptToken(Tags.CheckLocktimeVerify);
+		public static ScriptToken FromAltStack { get; } = new ScriptToken(Tags.FromAltStack);
+		public static ScriptToken ToAltStack { get; } = new ScriptToken(Tags.ToAltStack);
+		public static ScriptToken Drop { get; } = new ScriptToken(Tags.Drop);
+		public static ScriptToken Dup { get; } = new ScriptToken(Tags.Dup);
+		public static ScriptToken If { get; } = new ScriptToken(Tags.If);
+		public static ScriptToken IfDup { get; } = new ScriptToken(Tags.IfDup);
+		public static ScriptToken NotIf { get; } = new ScriptToken(Tags.NotIf);
+		public static ScriptToken Else { get; } = new ScriptToken(Tags.Else);
+		public static ScriptToken EndIf { get; } = new ScriptToken(Tags.EndIf);
+		public static ScriptToken ZeroNotEqual { get; } = new ScriptToken(Tags.ZeroNotEqual);
+		public static ScriptToken Size { get; } = new ScriptToken(Tags.Size);
+		public static ScriptToken Swap { get; } = new ScriptToken(Tags.Swap);
+		public static ScriptToken Verify { get; } = new ScriptToken(Tags.Verify);
+		public static ScriptToken Ripemd160 { get; } = new ScriptToken(Tags.Ripemd160);
+		public static ScriptToken Hash160 { get; } = new ScriptToken(Tags.Hash160);
+		public static ScriptToken Sha256 { get; } = new ScriptToken(Tags.Sha256);
+		public static ScriptToken Hash256 { get; } = new ScriptToken(Tags.Hash256);
+
+		internal class Number : ScriptToken
+		{
+			internal uint Item { get; }
+			internal Number(uint item) : base(Tags.Number) => Item = item;
+		}
+
+		internal class Hash20 : ScriptToken
+		{
+			internal uint160 Item { get; }
+			internal Hash20(uint160 item) : base(Tags.Hash20)
+			{
+				Item = item;
+			}
+		}
+		internal class Hash32 : ScriptToken
+		{
+			internal uint256 Item { get; }
+			internal Hash32(uint256 item) : base(Tags.Hash32) => Item = item;
+		}
+		internal class Pk : ScriptToken
+		{
+			internal PubKey Item { get; }
+			internal Pk(PubKey item) : base(Tags.Pk) => Item = item;
+		}
+
+
+		public sealed override int GetHashCode()
+		{
+			int num = 0;
+			switch (Tag)
+			{
+				case Tags.Number:
+					{
+						Number number = (Number)this;
+						num = Tags.Number;
+						return -1640531527 + ((int)number.Item + ((num << 6) + (num >> 2)));
+					}
+				case Tags.Hash20:
+					{
+						Hash20 hash160 = (Hash20)this;
+						num = Tags.Hash20;
+						return -1640531527 + (hash160.Item.GetHashCode()) + ((num << 6) + (num >> 2));
+					}
+				case Tags.Hash32:
+					{
+						Hash32 sha256Hash = (Hash32)this;
+						num = Tags.Hash32;
+						return -1640531527 + (sha256Hash.Item.GetHashCode()) + ((num << 6) + (num >> 2));
+					}
+				case Tags.Pk:
+					{
+						Pk pk = (Pk)this;
+						num = Tags.Hash32;
+						return -1640531527 + (pk.Item.GetHashCode()) + ((num << 6) + (num >> 2));
+					}
+				default:
+					return Tag;
+			}
+		}
+
+		public sealed override bool Equals(object obj)
+			=> Equals(obj as ScriptToken);
+		public bool Equals(ScriptToken obj)
+		{
+			if (obj == null)
+				return false;
+			int tag = Tag;
+			int tag2 = obj.Tag;
+			if (tag == tag2)
+			{
+				switch (Tag)
+				{
+					case Tags.Number:
+						{
+							Number number = (Number)this;
+							Number number2 = (Number)obj;
+							return number.Item == number2.Item;
+						}
+					case Tags.Hash20:
+						{
+							Hash20 hash160 = (Hash20)this;
+							Hash20 hash160Hash2 = (Hash20)obj;
+							return hash160.Item == hash160Hash2.Item;
+						}
+					case Tags.Hash32:
+						{
+							Hash32 sha256Hash = (Hash32)this;
+							Hash32 sha256Hash2 = (Hash32)obj;
+							return sha256Hash.Item == sha256Hash2.Item;
+						}
+					case Tags.Pk:
+						{
+							Pk pk = (Pk)this;
+							Pk pk2 = (Pk)obj;
+							return pk.Item == pk2.Item;
+						}
+					default:
+						return true;
+				}
+			}
+			return false;
+		}
+
+		public static ScriptToken[] FromScript(Script script)
+		{
+			var ret = new List<ScriptToken>();
+			foreach (var s in script.ToOps())
+			{
+				switch (s.Code)
+				{
+					case OpcodeType.OP_BOOLAND:
+						ret.Add(BoolAnd);
+						break;
+					case OpcodeType.OP_BOOLOR:
+						ret.Add(BoolOr);
+						break;
+					case OpcodeType.OP_EQUAL:
+						ret.Add(Equal);
+						break;
+					case OpcodeType.OP_EQUALVERIFY:
+						ret.Add(Equal);
+						ret.Add(Verify);
+						break;
+					case OpcodeType.OP_CHECKSIG:
+						ret.Add(CheckSig);
+						break;
+					case OpcodeType.OP_CHECKSIGVERIFY:
+						ret.Add(CheckSig);
+						ret.Add(Verify);
+						break;
+					case OpcodeType.OP_CHECKMULTISIG:
+						ret.Add(CheckMultiSig);
+						break;
+					case OpcodeType.OP_CHECKMULTISIGVERIFY:
+						ret.Add(CheckMultiSig);
+						ret.Add(Verify);
+						break;
+					case OpcodeType.OP_CHECKSEQUENCEVERIFY:
+						ret.Add(CheckSequenceVerify);
+						break;
+					case OpcodeType.OP_CHECKLOCKTIMEVERIFY:
+						ret.Add(CheckLocktimeVerify);
+						break;
+					case OpcodeType.OP_FROMALTSTACK:
+						ret.Add(FromAltStack);
+						break;
+					case OpcodeType.OP_TOALTSTACK:
+						ret.Add(ToAltStack);
+						break;
+					case OpcodeType.OP_DROP:
+						ret.Add(Drop);
+						break;
+					case OpcodeType.OP_DUP:
+						ret.Add(Dup);
+						break;
+					case OpcodeType.OP_ADD:
+						ret.Add(Add);
+						break;
+					case OpcodeType.OP_IF:
+						ret.Add(If);
+						break;
+					case OpcodeType.OP_NOTIF:
+						ret.Add(NotIf);
+						break;
+					case OpcodeType.OP_ELSE:
+						ret.Add(Else);
+						break;
+					case OpcodeType.OP_ENDIF:
+						ret.Add(EndIf);
+						break;
+					case OpcodeType.OP_0NOTEQUAL:
+						ret.Add(ZeroNotEqual);
+						break;
+					case OpcodeType.OP_SIZE:
+						ret.Add(Size);
+						break;
+					case OpcodeType.OP_SWAP:
+						ret.Add(Swap);
+						break;
+					case OpcodeType.OP_VERIFY:
+						var last = ret.LastOrDefault();
+						if (last.Equals(Equal) || last.Equals(CheckSig) || last.Equals(CheckMultiSig))
+							throw new ParsingException($"Miniscript must use truncated OP_*VERIFY but got separated representation {last} and OP_VERIFY when deserializing");
+						ret.Add(Verify);
+						break;
+					case OpcodeType.OP_SHA256:
+						ret.Add(Sha256);
+						break;
+					case OpcodeType.OP_HASH256:
+						ret.Add(Sha256);
+						break;
+					case OpcodeType.OP_RIPEMD160:
+						ret.Add(Ripemd160);
+						break;
+					case OpcodeType.OP_HASH160:
+						ret.Add(Hash160);
+						break;
+					case OpcodeType.OP_0:
+						ret.Add(new Number(0u));
+						break;
+					case OpcodeType.OP_1:
+						ret.Add(new Number(1u));
+						break;
+					case OpcodeType.OP_2:
+						ret.Add(new Number(2u));
+						break;
+					case OpcodeType.OP_3:
+						ret.Add(new Number(3u));
+						break;
+					case OpcodeType.OP_4:
+						ret.Add(new Number(4u));
+						break;
+					case OpcodeType.OP_5:
+						ret.Add(new Number(5u));
+						break;
+					case OpcodeType.OP_6:
+						ret.Add(new Number(6u));
+						break;
+					case OpcodeType.OP_7:
+						ret.Add(new Number(7u));
+						break;
+					case OpcodeType.OP_8:
+						ret.Add(new Number(8u));
+						break;
+					case OpcodeType.OP_9:
+						ret.Add(new Number(9u));
+						break;
+					case OpcodeType.OP_10:
+						ret.Add(new Number(10u));
+						break;
+					case OpcodeType.OP_11:
+						ret.Add(new Number(11u));
+						break;
+					case OpcodeType.OP_12:
+						ret.Add(new Number(12u));
+						break;
+					case OpcodeType.OP_13:
+						ret.Add(new Number(13u));
+						break;
+					case OpcodeType.OP_14:
+						ret.Add(new Number(14u));
+						break;
+					case OpcodeType.OP_15:
+						ret.Add(new Number(15u));
+						break;
+					case OpcodeType.OP_16:
+						ret.Add(new Number(16u));
+						break;
+					default:
+						if (0x01 <= (byte) s.Code && (byte) s.Code < 0x48)
+							ret.Add(GetItem(s));
+						else if (0x48 <= (byte)s.Code)
+							throw new ParsingException($"Miniscript does not support pushdata bigger than 33. Got {s}");
+						else
+							throw new ParsingException($"Unknown Opcode to Miniscript {s.Name}");
+						break;
+				}
+			}
+			ret.Reverse();
+			return ret.ToArray();
+		}
+
+		private static ScriptToken GetItem(Op op)
+		{
+			if (op.PushData.Length == 20)
+				return new Hash20(new uint160(op.PushData, false));
+			if (op.PushData.Length == 32)
+				return new Hash32(new uint256(op.PushData, false));
+			if (op.PushData.Length == 33)
+			{
+				try
+				{
+					return new Pk(new PubKey(op.PushData));
+				}
+				catch (FormatException ex)
+				{
+					throw new ParsingException("Invalid Public Key", ex);
+				}
+			}
+
+			var i = op.GetInt();
+			if (i.HasValue)
+				return new Number((uint)i.Value);
+			throw new ParsingException($"Invalid push with Opcode {op}");
+		}
+
+		public override string ToString()
+		{
+			switch (this.Tag)
+			{
+				case Tags.BoolAnd:
+					return "BoolAnd";
+				case Tags.BoolOr:
+					return "BoolAnd";
+				case Tags.Add:
+					return "Add";
+				case Tags.Equal:
+					return "Equal";
+				case Tags.CheckSig:
+					return "CheckSig";
+				case Tags.CheckMultiSig:
+					return "CheckMultiSig";
+				case Tags.CheckSequenceVerify:
+					return "CheckSequenceVerify";
+				case Tags.CheckLocktimeVerify:
+					return "CheckLocktimeVerify";
+				case Tags.FromAltStack:
+					return "FromAltStack";
+				case Tags.ToAltStack:
+					return "ToAltStack";
+				case Tags.Drop:
+					return "Drop";
+				case Tags.Dup:
+					return "Dup";
+				case Tags.If:
+					return "If";
+				case Tags.IfDup:
+					return "IfDup";
+				case Tags.NotIf:
+					return "NotIf";
+				case Tags.Else:
+					return "Else";
+				case Tags.EndIf:
+					return "EndIf";
+				case Tags.ZeroNotEqual:
+					return "ZeroNotEqual";
+				case Tags.Size:
+					return "Size";
+				case Tags.Swap:
+					return "Swap";
+				case Tags.Verify:
+					return "Verify";
+				case Tags.Ripemd160:
+					return "Ripemd160";
+				case Tags.Hash160:
+					return "Hash160";
+				case Tags.Sha256:
+					return "Sha256";
+				case Tags.Hash256:
+					return "Hash256";
+				case Tags.Number:
+					var n = ((Number)this).Item;
+					return $"Number({n})";
+				case Tags.Hash20:
+					var hash20 = ((Hash20)this).Item;
+					return $"Hash20({hash20})";
+				case Tags.Hash32:
+					var hash32 = ((Hash32)this).Item;
+					return $"Hash30({hash32})";
+				case Tags.Pk:
+					var pk = ((Pk)this).Item;
+					return $"Pk({pk})";
+			}
+			throw new Exception("Unreachable");
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Tree.cs b/NBitcoin/Scripting/Miniscript/Tree.cs
new file mode 100644
index 0000000000..679b7e8ab5
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Tree.cs
@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using NBitcoin.Scripting.Parser;
+using System.Linq;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	/// <summary>
+	/// A token of the from `x()` or `x`
+	/// </summary>
+	public class Tree
+	{
+		public readonly string Name;
+		public readonly List<Tree> Args;
+
+		public Tree(string name, List<Tree> args)
+		{
+			Name = name;
+			Args = args;
+		}
+
+
+		public static Tree Parse(string str)
+		{
+			var topAndRemaining = FromSlice(str);
+			var top = topAndRemaining.Item1;
+			var remaining = topAndRemaining.Item2;
+			if (remaining.Length == 0)
+				return top;
+			throw new ParsingException($"There was remaining input after parsing. Remaining: {remaining}");
+		}
+
+		private enum Found
+		{
+			LParen,
+			Nothing,
+			Comma,
+			RParen
+		}
+		private static Tuple<Tree, string> FromSlice(string str)
+		{
+			var found = new { Found = Found.Nothing, Pos = 0 };
+			for (var n = 0; n < str.Length; n++)
+			{
+				var ch = str[n];
+				if (ch == '(') { found = new { Found = Found.LParen, Pos = n}; break; }
+				if (ch == ',') { found = new { Found = Found.Comma, Pos = n}; break; }
+				if (ch == ')') { found = new { Found = Found.RParen, Pos = n}; break; }
+			}
+
+			switch (found.Found)
+			{
+				case Found.Nothing: return new Tuple<Tree, string>(new Tree(str, new List<Tree>()), "");
+				case Found.Comma:
+					var strToComma = str.Substring(0, found.Pos);
+					var strFromComma = str.Substring(found.Pos);
+					return new Tuple<Tree, string>(new Tree(strToComma, new List<Tree>()), strFromComma);
+				case Found.RParen:
+					var strToRParen = str.Substring(0, found.Pos);
+					var strFromRParen = str.Substring(found.Pos);
+					return new Tuple<Tree, string>(new Tree(strToRParen, new List<Tree>()), strFromRParen);
+				case Found.LParen:
+					var strToLParen = str.Substring(0, found.Pos);
+					var ret = new Tree(strToLParen, new List<Tree>());
+					str = str.Substring(found.Pos + 1);
+					while (true)
+					{
+						var t = Tree.FromSlice(str);
+						var remain = t.Item2;
+						ret.Args.Add(t.Item1);
+						if (remain.Length == 0)
+							throw new ParsingException("Miniscript does not terminate with )");
+						str = remain.Substring(1);
+						if (remain[0] == ',') {}
+						else if (remain[0] == ')') break;
+						else throw new ParsingException($"expecting char , (comma) . but got {remain[0]}");
+					}
+					return Tuple.Create(ret, str);
+			}
+			throw new NotImplementedException();
+		}
+
+		internal static T Terminal<T>(Tree term, Func<string, T> convert)
+		{
+			if (term.Args.Count == 0)
+			{
+				try
+				{
+					return convert(term.Name);
+				}
+				catch (NotSupportedException ex)
+				{
+					throw new ParsingException(term.Name, ex);
+				}
+			}
+			throw new ParsingException(term.Name);
+		}
+
+		internal static Terminal<TPk, TPKh> Binary<TPk, TPKh>(
+			Tree term,
+			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> constructor)
+			where TPk : class, IMiniscriptKey<TPKh>, new()
+			where TPKh : class, IMiniscriptKeyHash, new()
+		{
+			if (term.Args.Count == 2)
+			{
+				var left = Miniscript<TPk, TPKh>.FromTree(term.Args[0]);
+				var right = Miniscript<TPk, TPKh>.FromTree(term.Args[1]);
+				return constructor(left, right);
+			}
+			throw new ParsingException(term.Name);
+		}
+
+		internal static Terminal<TPk, TPKh> Ternary<TPk, TPKh>(
+			Tree term,
+			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>,Terminal<TPk, TPKh>> constructor)
+			where TPk : class, IMiniscriptKey<TPKh>, new()
+			where TPKh : class, IMiniscriptKeyHash, new()
+		{
+			if (term.Args.Count == 3)
+			{
+				var a = Miniscript<TPk, TPKh>.FromTree(term.Args[0]);
+				var b = Miniscript<TPk, TPKh>.FromTree(term.Args[1]);
+				var c = Miniscript<TPk, TPKh>.FromTree(term.Args[2]);
+				return constructor(a, b, c);
+			}
+			throw new ParsingException(term.Name);
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
new file mode 100644
index 0000000000..0a92aefe22
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
@@ -0,0 +1,525 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+	[DebuggerDisplay("{" + nameof(DebugPrint) + "()}")]
+	internal class Correctness : IProperty<Correctness>
+	{
+		public readonly Base Base;
+		public readonly Input Input;
+		public readonly bool DisSatisfiable;
+		/// <summary>
+		/// Whether the fragment's "nonzero' output on satisfaction is
+		/// always the constant 1.
+		/// </summary>
+		public bool Unit;
+
+		public Correctness() {}
+
+		public Correctness(Base @base, Input input, bool disSatisfiable, bool unit)
+		{
+			Base = @base;
+			Input = input;
+			DisSatisfiable = disSatisfiable;
+			Unit = unit;
+		}
+
+		internal string DebugPrint()
+			=> $"Input: {Input.DebugPrint()}; Base: {Base.ToString()}";
+
+		public bool IsSubtype(Correctness other) =>
+			(this.Base == other.Base) &&
+			(this.Input.IsSubtype(other.Input)) &&
+			(!(!(this.DisSatisfiable) && other.DisSatisfiable)) &&
+			(!(!(this.Unit) && other.Unit));
+
+		public override void SanityChecks()
+		{
+			if (Base == Base.B) return;
+			if (Base == Base.K) Debug.Assert(Unit);
+			if (Base == Base.V)
+			{
+				Debug.Assert(Unit);
+				Debug.Assert(DisSatisfiable);
+			}
+
+			if (Base == Base.W)
+			{
+				Debug.Assert(Input != Input.OneNonZero);
+				Debug.Assert(Input != Input.AnyNonZero);
+			}
+		}
+
+		public override Correctness FromTrue()
+			=> new Correctness(Base.B, Input.Zero, false, true);
+
+		public override Correctness FromFalse()
+			=> new Correctness(Base.B, Input.Zero, true, true);
+
+		public override Correctness FromPk()
+			=> new Correctness(Base.K, Input.OneNonZero, true, true);
+
+		public override Correctness FromPkH()
+			=> new Correctness(Base.K, Input.AnyNonZero, true, true);
+
+		public override Correctness FromMulti(int k, int pkLength)
+			=> new Correctness(Base.B, Input.AnyNonZero, true, true);
+
+		public override Correctness FromHash()
+			=> new Correctness(Base.B, Input.OneNonZero, true, true);
+
+		public override Correctness FromTime(uint time)
+			=> new Correctness(Base.B, Input.Zero, false, false);
+
+		public override bool TryCastAlt(out Correctness result, List<FragmentPropertyException> fragmentPropertyExceptions)
+		{
+			result = null;
+			if (this.Base != Miniscript.Base.B)
+			{
+				fragmentPropertyExceptions.Add(FragmentPropertyException.ChildBase1(Base));
+				return false;
+			}
+
+			result =
+				new Correctness(
+					Base.W,
+					Input.Any,
+					DisSatisfiable,
+					Unit
+				);
+			return true;
+		}
+
+		public override bool TryCastSwap(out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (this.Base != Base.B)
+			{
+				error.Add(FragmentPropertyException.ChildBase1(Base));
+				return false;
+			}
+			if (Input != Input.One && Input != Input.OneNonZero)
+			{
+				error.Add(FragmentPropertyException.SwapNoneOne());
+				return false;
+			}
+
+			result = new Correctness(
+				Base.W,
+				Input.Any,
+				DisSatisfiable,
+				Unit
+			);
+			return true;
+		}
+
+		public override bool TryCastCheck(out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (Base != Base.K)
+			{
+				error.Add(FragmentPropertyException.ChildBase1(Base));
+				return false;
+			}
+			result = new Correctness(
+				Miniscript.Base.B,
+				Input,
+				DisSatisfiable,
+				true
+			);
+			return true;
+		}
+
+		public override bool TryCastDupIf(out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (this.Base != Base.V)
+			{
+				error.Add(FragmentPropertyException.ChildBase1(Base));
+				return false;
+			}
+
+			if (this.Input != Input.Zero)
+			{
+				error.Add(FragmentPropertyException.NonZeroDupIf());
+				return false;
+			}
+			result = new Correctness(
+				Base.B,
+				Input.OneNonZero,
+				true,
+				true
+			);
+			return true;
+		}
+
+		public override bool TryCastVerify(out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (this.Base != Base.B)
+			{
+				error.Add(FragmentPropertyException.ChildBase1(Base));
+				return false;
+			}
+			result = new Correctness(
+				Base.V,
+				Input,
+				false, false
+			);
+			return true;
+		}
+
+		public override bool TryCastNonZero(out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (this.Base != Base.B)
+			{
+				error.Add(FragmentPropertyException.ChildBase1(Base));
+				return false;
+			}
+			if (Input != Input.OneNonZero && Input != Input.AnyNonZero)
+			{
+				error.Add(FragmentPropertyException.NonZeroZero());
+				return false;
+			}
+
+			result =
+				new Correctness(
+					Base.B,
+				Input,
+				true,
+				Unit
+				);
+			return true;
+		}
+
+		public override bool TryCastZeroNotEqual(out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (this.Base != Base.B)
+			{
+				error.Add(FragmentPropertyException.ChildBase1(Base));
+				return false;
+			}
+			result = new Correctness(
+				Base.B,
+				Input,
+				DisSatisfiable,
+				true
+			);
+			return true;
+		}
+
+		public override bool TryCastTrue(out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (this.Base != Base.V)
+			{
+				error.Add(FragmentPropertyException.ChildBase1(Base));
+				return false;
+			}
+			result =
+			new Correctness(
+				Base.B,
+				Input,
+				false,
+				true
+			);
+			return true;
+		}
+
+		public override bool TryCastOrIFalse(out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (this.Base != Base.B)
+			{
+				error.Add(FragmentPropertyException.ChildBase1(Base));
+				return false;
+			}
+			result =
+			new Correctness(
+				Base.B,
+				(Input == Input.Zero ? Input.One : Input.Any),
+				true,
+				Unit
+			);
+			return true;
+		}
+
+		public override bool TryAndB(Correctness l, Correctness r, out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (l.Base != Base.B || r.Base != Base.W)
+			{
+				error.Add(FragmentPropertyException.ChildBase2(r.Base, l.Base));
+				return false;
+			}
+			result = new Correctness(
+				Miniscript.Base.B,
+				(l.Input == Input.Zero && r.Input == Input.Zero)
+					? Input.Zero
+					:
+					((l.Input == Input.Zero && r.Input == Input.One)
+					 || (l.Input == Input.One && r.Input == Input.Zero))
+						? Input.One
+						:
+						(l.Input == Input.Zero && r.Input == Input.OneNonZero)
+						|| (l.Input == Input.OneNonZero && r.Input == Input.Zero)
+							? Input.OneNonZero
+							:
+							((l.Input == Input.AnyNonZero) || (l.Input == Input.Zero && r.Input == Input.AnyNonZero))
+								?
+								Input.AnyNonZero
+								:
+								(Input.Any),
+				(l.DisSatisfiable && r.DisSatisfiable),
+				true
+			);
+			return true;
+		}
+
+		public override bool TryAndV(Correctness l, Correctness r, out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			var newBase =
+				(l.Base == Base.V && r.Base == Base.B) ? Base.B :
+				(l.Base == Base.V && r.Base == Base.K) ? Base.K :
+				(l.Base == Base.V && r.Base == Base.V) ? Base.V : Miniscript.Base.W;
+			if (newBase == Base.W)
+			{
+				error.Add(FragmentPropertyException.ChildBase2(l.Base, r.Base));
+				return false;
+			}
+			result =
+				new Correctness(
+					newBase,
+				(l.Input == Input.Zero && r.Input == Input.Zero) ? Input.Zero :
+				(l.Input == Input.Zero && r.Input == Input.One) ||
+					(l.Input == Input.One && r.Input == Input.Zero) ? Input.One :
+				(l.Input == Input.Zero && r.Input == Input.OneNonZero) ||
+					(l.Input == Input.OneNonZero && r.Input == Input.Zero) ? Input.OneNonZero :
+				(l.Input == Input.OneNonZero) ||
+					(l.Input == Input.AnyNonZero) ||
+					(l.Input == Input.Zero && r.Input == Input.AnyNonZero) ? Input.AnyNonZero :
+				Input.Any,
+				false,
+				r.Unit
+				);
+			return true;
+		}
+
+		public override bool TryOrB(Correctness l, Correctness r, out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (!l.DisSatisfiable)
+			{
+				error.Add(FragmentPropertyException.LeftNotDissatisfiable());
+				return false;
+			}
+
+			if (!r.DisSatisfiable)
+			{
+				error.Add(FragmentPropertyException.RightNotDissatisfiable());
+				return false;
+			}
+
+			if (l.Base != Base.B || r.Base != Base.W)
+			{
+				error.Add(FragmentPropertyException.ChildBase2(l.Base, r.Base));
+				return false;
+			}
+
+			result = new Correctness(
+				Miniscript.Base.B,
+				(l.Input == Miniscript.Input.Zero && r.Input == Miniscript.Input.Zero) ? Miniscript.Input.Zero :
+				(l.Input == Miniscript.Input.Zero && r.Input == Miniscript.Input.One) ||
+					(l.Input == Miniscript.Input.One && r.Input == Miniscript.Input.Zero) ||
+					(l.Input == Miniscript.Input.Zero && r.Input == Miniscript.Input.OneNonZero) ||
+					(l.Input == Miniscript.Input.OneNonZero && r.Input == Miniscript.Input.Zero) ? Miniscript.Input.One :
+				Miniscript.Input.Any,
+				true,
+				true
+				);
+			return true;
+		}
+
+		public override bool TryOrD(Correctness l, Correctness r, out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (!l.DisSatisfiable)
+			{
+				error.Add(FragmentPropertyException.LeftNotDissatisfiable());
+				return false;
+			}
+
+			if (!l.Unit)
+			{
+				error.Add(FragmentPropertyException.LeftNotUnit());
+				return false;
+			}
+
+			if (l.Base != Base.B || r.Base != Base.B)
+			{
+				error.Add(FragmentPropertyException.ChildBase2(l.Base, r.Base));
+				return false;
+			}
+
+			result = new Correctness(
+				Miniscript.Base.B,
+				(l.Input == Miniscript.Input.Zero && r.Input == Miniscript.Input.Zero) ? Miniscript.Input.Zero :
+					(l.Input == Miniscript.Input.One && r.Input == Miniscript.Input.Zero) ||
+					(l.Input == Miniscript.Input.OneNonZero && r.Input == Miniscript.Input.Zero) ? Miniscript.Input.One :
+				Miniscript.Input.Any,
+				r.DisSatisfiable,
+				r.Unit
+				);
+			return true;
+		}
+
+		public override bool TryOrC(Correctness l, Correctness r, out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (!l.DisSatisfiable)
+			{
+				error.Add(FragmentPropertyException.LeftNotDissatisfiable());
+				return false;
+			}
+
+			if (!l.Unit)
+			{
+				error.Add(FragmentPropertyException.LeftNotUnit());
+				return false;
+			}
+
+			if (l.Base != Base.B || r.Base != Base.V)
+			{
+				error.Add(FragmentPropertyException.ChildBase2(l.Base, r.Base));
+				return false;
+			}
+
+			result =
+				new Correctness(
+					Base.V,
+					Miniscript.Input.Any,
+					false,
+					false
+				);
+			return true;
+		}
+
+		public override bool TryOrI(Correctness l, Correctness r, out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			var nextBase =
+				(l.Base == Miniscript.Base.B && r.Base == Miniscript.Base.B) ? Miniscript.Base.B :
+				(l.Base == Miniscript.Base.V && r.Base == Miniscript.Base.V) ? Miniscript.Base.V :
+				(l.Base == Miniscript.Base.K && r.Base == Miniscript.Base.K) ? Miniscript.Base.K :
+				Miniscript.Base.W;
+			if (nextBase == Base.W)
+			{
+				error.Add(FragmentPropertyException.ChildBase2(l.Base, r.Base));
+				return false;
+			}
+			result = new Correctness(
+				nextBase,
+				(l.Input == Miniscript.Input.Zero && r.Input == Miniscript.Input.Zero)
+					? Miniscript.Input.One
+					: Miniscript.Input.Any,
+				(l.DisSatisfiable || r.DisSatisfiable),
+				l.Unit && r.Unit
+			);
+			return true;
+		}
+
+		public override bool TryAndOr(Correctness a, Correctness b, Correctness c, out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (!a.DisSatisfiable)
+			{
+				error.Add(FragmentPropertyException.LeftNotDissatisfiable());
+				return false;
+			}
+
+			if (!a.Unit)
+			{
+				error.Add(FragmentPropertyException.LeftNotUnit());
+				return false;
+			}
+
+			var nextBase =
+				(a.Base == Base.B && b.Base == Base.B && c.Base == Base.B) ? Miniscript.Base.B :
+				(a.Base == Base.B && b.Base == Base.K && c.Base == Base.K) ? Base.K :
+				(a.Base == Base.B && b.Base == Base.V && c.Base == Base.V) ? Base.V :
+				Base.W;
+			if (nextBase == Base.W)
+			{
+				error.Add(FragmentPropertyException.ChildBase3(a.Base, b.Base, c.Base));
+				return false;
+			}
+			result = new Correctness(
+				nextBase,
+				(a.Input == Input.Zero && b.Input == Input.Zero && c.Input == Input.Zero) ? Input.Zero :
+				(a.Input == Input.Zero && b.Input == Input.One && c.Input == Input.One) ||
+					(a.Input  == Input.Zero && b.Input == Input.One && c.Input == Input.OneNonZero) ||
+					(a.Input == Input.Zero && b.Input == Input.OneNonZero && c.Input == Input.One) ||
+					(a.Input == Input.Zero && b.Input == Input.OneNonZero && c.Input == Input.OneNonZero) ||
+					(a.Input == Input.One && b.Input == Input.Zero && c.Input == Input.Zero) ||
+					(a.Input == Input.OneNonZero && b.Input == Input.Zero && c.Input == Input.Zero)
+					? Input.One :
+					Input.Any,
+				c.DisSatisfiable,
+				b.Unit && c.Unit
+				);
+			return true;
+		}
+
+		public override bool TryThreshold(int k, int n, SubCk ck, out Correctness result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			var isN = k == n;
+			for (int i = 0; i < n; i++)
+			{
+				if (!ck(i, out var subType, error))
+					return false;
+				if (i == 0)
+				{
+					isN &= subType.Input == Input.OneNonZero || subType.Input == Input.AnyNonZero;
+					if (subType.Base != Base.B)
+					{
+						error.Add(FragmentPropertyException.ThresholdBase(0U, subType.Base));
+						return false;
+					}
+				}
+				else
+				{
+					if (subType.Base != Miniscript.Base.W)
+					{
+						error.Add(FragmentPropertyException.ThresholdBase((uint) n, subType.Base));
+						return false;
+					}
+				}
+
+				if (!subType.Unit)
+				{
+					error.Add(FragmentPropertyException.ThresholdNonUnit((uint) n));
+					return false;
+				}
+
+				if (!subType.DisSatisfiable)
+				{
+					error.Add(FragmentPropertyException.ThresholdDissat((uint) n));
+					return false;
+				}
+			}
+			result = new Correctness(
+				Base.B,
+				(isN ? Input.AnyNonZero : Miniscript.Input.Any),
+				true,
+				true
+				);
+			return true;
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/ExtData.cs b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
new file mode 100644
index 0000000000..3fae6efe1f
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
@@ -0,0 +1,487 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+
+	internal static class Constants
+	{
+		internal const int MAX_OPS_PER_SCRIPT = 201;
+	}
+
+	/// <summary>
+	///  Whether a fragment is OK to be used in non-segwit scripts
+	/// </summary>
+	internal enum LegacySafe
+	{
+		/// <summary>
+		/// The fragment can be used in pre-segwit contexts without concern about malleability
+		/// attacks/unbounded 3rd-party fee stuffing. This means it has no `pk_h` constructions
+		/// (cannot estimate public key size from a hash) and no `d:`/`or_i` constructions
+		/// (cannot control the size of the switch input to `OP_IF`)
+		/// </summary>
+		LegacySafe,
+		/// <summary>
+		/// This fragment can only be safely used with Segwit.
+		/// </summary>
+		SegwitOnly
+	}
+
+	/// <summary>
+	/// Structure representing the extra type properties of a fragment which are relevant to legacy (pre-segwit)
+	/// safety and fee estimation. If a fragment is used in pre-segwit transactions it will only
+	/// be malleable but still is correct and sound.
+	/// </summary>
+	internal class ExtData : IProperty<ExtData>
+	{
+		/// <summary>
+		/// enum sorting whether the fragment is safe to be in used in pre-segwit context
+		/// </summary>
+		internal readonly LegacySafe LegacySafe;
+		/// <summary>
+		/// The number of bytes needed to encode its scriptPubKey
+		/// </summary>
+		internal readonly ulong PkCost;
+		/// <summary>
+		/// Whether this fragment can be verify-wrapped for free.
+		/// </summary>
+		internal readonly bool HasVerifyForm;
+		/// <summary>
+		/// The worst case static (unexecuted) ops-count for this miniscript fragment.
+		/// </summary>
+		internal readonly ulong OpsCountStatic;
+		/// <summary>
+		/// The worst case ops-count for satisfying this Miniscript fragment.
+		/// </summary>
+		internal readonly ulong?  OpsCountSat;
+		/// <summary>
+		/// The worst case ops-count for dissatisfying this Miniscript fragment.
+		/// </summary>
+		internal readonly ulong? OpsCountNSat;
+
+		public ExtData() {}
+
+		public ExtData(LegacySafe legacySafe, ulong pkCost, bool hasVerifyForm, ulong opsCountStatic, ulong? opsCountSat, ulong? opsCountNSat)
+		{
+			LegacySafe = legacySafe;
+			PkCost = pkCost;
+			HasVerifyForm = hasVerifyForm;
+			OpsCountStatic = opsCountStatic;
+			OpsCountSat = opsCountSat;
+			OpsCountNSat = opsCountNSat;
+		}
+
+		public override ExtData FromTrue() =>
+			new ExtData(
+				LegacySafe.LegacySafe,
+				1U,
+				false,
+				0UL,
+				0,
+				null
+				);
+
+		public override ExtData FromFalse() =>
+			new ExtData(
+				LegacySafe.LegacySafe,
+				1U,
+				false,
+				0UL,
+				null,
+				0
+				);
+
+		public override ExtData FromPk() =>
+			new ExtData(
+				LegacySafe.LegacySafe,
+				34,
+				false,
+				0,
+				0,
+				0
+				);
+
+		public override ExtData FromPkH() =>
+			new ExtData(
+				LegacySafe.SegwitOnly,
+				24,
+				false,
+				3,
+				3,
+				3
+				);
+
+		public override ExtData FromMulti(int k, int n)
+		{
+			var numCost =
+				((k > 16) && (n > 16)) ? 4 :
+				(!(k > 16) && (n > 16)) ? 3 :
+				((k > 16) && !(n > 16)) ? 3 :
+				2;
+			return new ExtData(
+				LegacySafe.LegacySafe,
+				((ulong)numCost + 34UL * (ulong)n + 1UL),
+				true,
+				1,
+				(ulong)n + 1UL,
+				(ulong)n + 1UL
+				);
+		}
+
+
+		public override ExtData FromHash()
+		{
+			throw new Exception("Unreachable");
+		}
+
+		public override ExtData FromSha256() =>
+			new ExtData(
+				LegacySafe.LegacySafe,
+				33 + 6,
+				true,
+				4,
+				4,
+				null
+				);
+
+		public override ExtData FromHash256() => FromSha256();
+
+		public override ExtData FromRipemd160() =>
+			new ExtData(
+				LegacySafe.LegacySafe,
+				21 + 6,
+				true,
+				4,
+				4,
+				null
+				);
+
+		public override ExtData FromHash160() => FromRipemd160();
+
+		public override ExtData FromTime(uint time) =>
+			new ExtData(
+				LegacySafe.LegacySafe,
+				(ulong)Miniscript.Utils.ScriptNumSize(time) + 1UL,
+				false,
+				1,
+				1,
+				null
+				);
+
+		public override bool TryCastAlt(out ExtData result, List<FragmentPropertyException> error)
+		{
+			result =
+				new ExtData(
+					LegacySafe,
+					PkCost + 2,
+					false,
+					OpsCountStatic + 2,
+					OpsCountSat + 2,
+					OpsCountNSat + 2
+				);
+			return true;
+		}
+
+		public override bool TryCastSwap(out ExtData result, List<FragmentPropertyException> error)
+		{
+			result =
+			new ExtData(
+				LegacySafe,
+				PkCost + 1,
+				HasVerifyForm,
+				OpsCountStatic + 1,
+				OpsCountSat + 1,
+				OpsCountNSat + 1
+			);
+			return true;
+		}
+
+		public override bool TryCastCheck(out ExtData result, List<FragmentPropertyException> error) {
+			result =
+			new ExtData(
+				LegacySafe,
+				PkCost + 1,
+				true,
+				OpsCountStatic + 1,
+				OpsCountSat + 1,
+				OpsCountNSat + 1
+				);
+			return true;
+		}
+
+		public override bool TryCastDupIf(out ExtData result, List<FragmentPropertyException> error) {
+			result =
+			new ExtData(
+				LegacySafe.SegwitOnly,
+				PkCost + 3,
+				false,
+				OpsCountStatic + 3,
+				OpsCountSat + 3,
+				OpsCountStatic + 3
+				);
+			return true;
+		}
+
+		public override bool TryCastVerify(out ExtData result, List<FragmentPropertyException> error)
+		{
+			var verifyCost = this.HasVerifyForm ? 0UL : 1UL;
+			result =
+			new ExtData(
+				LegacySafe,
+				PkCost + verifyCost,
+				false,
+				OpsCountStatic + verifyCost,
+				OpsCountSat + verifyCost,
+				null
+				);
+			return true;
+		}
+
+		public override bool TryCastNonZero(out ExtData result, List<FragmentPropertyException> error)
+		{
+			result =
+				new ExtData(
+					LegacySafe,
+					PkCost + 4UL,
+					false,
+					OpsCountStatic + 4,
+					OpsCountSat + 4UL,
+					OpsCountStatic + 4
+				);
+			return true;
+		}
+
+		public override bool TryCastZeroNotEqual(out ExtData result, List<FragmentPropertyException> error) {
+			result =
+			new ExtData(
+				LegacySafe,
+				PkCost + 1,
+				false,
+				OpsCountStatic + 1,
+				OpsCountSat + 1UL,
+				OpsCountNSat + 1UL
+				);
+			return true;
+		}
+
+		public override bool TryCastTrue(out ExtData result, List<FragmentPropertyException> error) {
+			result =
+			new ExtData(
+				LegacySafe,
+				PkCost + 1,
+				false,
+				OpsCountStatic,
+				OpsCountSat,
+				null
+				);
+			return true;
+		}
+
+		public override bool TryCastOrIFalse(out ExtData result, List<FragmentPropertyException> error)
+		{
+			throw new Exception("Unreachable!");
+		}
+
+		public override bool TryCastUnLikely(out ExtData result, List<FragmentPropertyException> error) {
+			result =
+			new ExtData(
+				LegacySafe,
+				PkCost + 4,
+				false,
+				OpsCountStatic + 3,
+				OpsCountSat + 3,
+				OpsCountNSat + 3
+				);
+			return true;
+		}
+
+		public override bool TryCastLikely(out ExtData result, List<FragmentPropertyException> error) {
+			result =
+			new ExtData(
+				LegacySafe,
+				PkCost + 4,
+				false,
+				OpsCountStatic + 3,
+				OpsCountSat + 3,
+				OpsCountStatic + 3
+				);
+			return true;
+		}
+		private static LegacySafe LegacySafe2(LegacySafe a, LegacySafe b) =>
+			(a == LegacySafe.LegacySafe && b == LegacySafe.LegacySafe) ? LegacySafe.LegacySafe : LegacySafe.SegwitOnly;
+		public override bool TryAndB(ExtData l, ExtData r, out ExtData result, List<FragmentPropertyException> error)
+		{
+			result =
+				new ExtData(
+					LegacySafe2(l.LegacySafe, r.LegacySafe),
+					l.PkCost + r.PkCost + 1,
+					false,
+					l.OpsCountStatic + r.OpsCountStatic + 1,
+					l.OpsCountSat + r.OpsCountSat + 1,
+					l.OpsCountNSat + r.OpsCountNSat + 1
+				);
+			return true;
+		}
+
+		public override bool TryAndV(ExtData l, ExtData r, out ExtData result, List<FragmentPropertyException> error)
+		{
+			result =
+			  new ExtData(
+				LegacySafe2(l.LegacySafe, r.LegacySafe),
+				l.PkCost + r.PkCost,
+				r.HasVerifyForm,
+				l.OpsCountStatic + r.OpsCountStatic,
+				l.OpsCountSat + r.OpsCountSat,
+				null
+			);
+			return true;
+		}
+
+		public override bool TryOrB(ExtData left, ExtData right, out ExtData result, List<FragmentPropertyException> error)
+		{
+			result =
+			new ExtData(
+				LegacySafe2(left.LegacySafe, right.LegacySafe),
+				left.PkCost + right.PkCost + 1,
+				false,
+				left.OpsCountStatic + right.OpsCountStatic + 1,
+				left.OpsCountSat + right.OpsCountSat + 1,
+				left.OpsCountNSat + right.OpsCountNSat + 1
+			);
+			return true;
+		}
+
+		public override bool TryOrD(ExtData left, ExtData right, out ExtData result, List<FragmentPropertyException> error)
+		{
+			var opsCountSat1 = left.OpsCountSat + 3 + right.OpsCountStatic;
+			var opsCountSat2 = right.OpsCountSat + left.OpsCountNSat + 3;
+			result =
+			new ExtData(
+				LegacySafe.SegwitOnly,
+				left.PkCost + right.PkCost + 3,
+				false,
+				left.OpsCountStatic + right.OpsCountStatic + 1,
+				Nullable.Compare(opsCountSat1, opsCountSat2) > 0 ? opsCountSat1 : opsCountSat2,
+				left.OpsCountSat + right.OpsCountNSat + 3
+			);
+			return true;
+		}
+
+		public override bool TryOrC(ExtData left, ExtData right, out ExtData result, List<FragmentPropertyException> error)
+		{
+			var opsCountSat1 = left.OpsCountSat + 2 + right.OpsCountStatic;
+			var opsCountSat2 = right.OpsCountSat + left.OpsCountNSat + 2;
+
+			result =
+			new ExtData(
+				LegacySafe2(left.LegacySafe, right.LegacySafe),
+				left.PkCost + right.PkCost + 2,
+				false,
+				left.OpsCountStatic + right.OpsCountStatic + 2,
+				Nullable.Compare(opsCountSat1, opsCountSat2) > 0 ? opsCountSat1 : opsCountSat2,
+					null
+			);
+			return true;
+		}
+
+		public override bool TryOrI(ExtData left, ExtData right, out ExtData result, List<FragmentPropertyException> error)
+		{
+			var opsCountSat1 = left.OpsCountSat + right.OpsCountStatic + 3;
+			var opsCountSat2 = right.OpsCountSat + left.OpsCountStatic + 3;
+			var opsCountNSat =
+				(left.OpsCountNSat.HasValue && right.OpsCountNSat.HasValue)
+					? (Nullable.Compare(left.OpsCountNSat, right.OpsCountNSat) > 0
+						  ? left.OpsCountNSat
+						  : right.OpsCountNSat) + 3
+					: (left.OpsCountNSat.HasValue)
+						? left.OpsCountNSat + 3
+						: right.OpsCountNSat + 3;
+			result =
+			new ExtData(
+				LegacySafe2(left.LegacySafe, right.LegacySafe),
+				left.PkCost + right.PkCost + 3,
+				false,
+				left.OpsCountStatic + right.OpsCountStatic + 3,
+				Nullable.Compare(opsCountSat1, opsCountSat2) > 0 ? opsCountSat1 : opsCountSat2,
+				opsCountNSat
+				);
+			return true;
+		}
+
+		public override bool TryAndOr(ExtData a, ExtData b, ExtData c, out ExtData result, List<FragmentPropertyException> error)
+		{
+			var legacySafe = LegacySafe2(LegacySafe2(a.LegacySafe, b.LegacySafe), c.LegacySafe);
+			var opsCountSat1 = a.OpsCountSat + b.OpsCountSat + c.OpsCountStatic + 3;
+			var opsCountSat2 = a.OpsCountNSat + b.OpsCountStatic + c.OpsCountSat + 3;
+			var opsCountSat = Nullable.Compare(opsCountSat1, opsCountSat2) > 0 ? opsCountSat1 : opsCountSat2;
+
+			var opsCountNSat = c.OpsCountNSat +  b.OpsCountStatic + a.OpsCountNSat + 3;
+
+			result = new ExtData(
+				legacySafe,
+				a.PkCost + b.PkCost + c.PkCost + 2,
+				false,
+				a.OpsCountStatic + b.OpsCountStatic + c.OpsCountStatic + 3,
+				opsCountSat,
+				opsCountNSat
+				);
+			return true;
+		}
+
+		public override bool TryThreshold(int k, int n, SubCk ck, out ExtData result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			var pkCost = 1UL + (ulong)Utils.ScriptNumSize(k);
+			var legacySafe = LegacySafe.LegacySafe;
+			var opsCountStatic = 0UL;
+			var opsCountSatVec = new List<ulong?>();
+			var opsCountNSatSum = 0UL;
+			ulong? opsCountNSat = 0UL;
+			ulong? opsCountSat = 0UL;
+			var satCount = 0;
+			for (int i = 0; i < n; i++)
+			{
+				if (!ck(i, out var sub, error))
+					return false;
+				pkCost += sub.PkCost;
+				opsCountStatic += sub.OpsCountStatic;
+				if (sub.OpsCountSat.HasValue && sub.OpsCountNSat.HasValue)
+				{
+					opsCountSatVec.Add(sub.OpsCountSat.Value - sub.OpsCountNSat.Value);
+					opsCountNSat = opsCountNSat + sub.OpsCountNSat.Value;
+					opsCountNSatSum += sub.OpsCountNSat.Value;
+				}
+				else if (sub.OpsCountSat.HasValue)
+				{
+					satCount++;
+					opsCountSat = opsCountSat + sub.OpsCountSat.Value;
+					opsCountNSat = null;
+				}
+
+				legacySafe = LegacySafe2(legacySafe, sub.LegacySafe);
+			}
+
+			var remainingSat = k - satCount;
+			ulong sum = 0UL;
+			if (k < satCount || opsCountSatVec.Count < remainingSat)
+				opsCountSat = null;
+			else
+			{
+				opsCountSatVec.Sort();
+				opsCountSatVec.Reverse();
+				Func<ulong?, double> summer = v => v.Value;
+				sum = (ulong)opsCountSatVec.Skip(remainingSat).Sum(summer);
+			}
+			result = new ExtData(
+				legacySafe,
+				pkCost + (ulong)n - 1UL,
+				true,
+				opsCountStatic + ((ulong)n - 1UL) + 1UL,
+				opsCountSat + ((ulong)n - 1UL) + 1UL + (sum + opsCountNSatSum),
+				opsCountNSat + ((ulong)n - 1UL) + 1UL
+				);
+			return true;
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs b/NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs
new file mode 100644
index 0000000000..fe479c881b
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs
@@ -0,0 +1,176 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+
+	public enum ErrorKind
+	{
+		/// <summary>
+		/// Relative or absolute timelock had a time value of 0;
+		/// </summary>
+		ZeroTime,
+
+		/// <summary>
+		/// Multisignature or threshold policy had a `k` value of 0
+		/// </summary>
+		ZeroThreshold,
+
+		/// <summary>
+		/// Multisignature or threshold policy has a `k` value in excess of the number of
+		/// sub-fragments
+		/// </summary>
+		OverThreshold,
+
+		/// <summary>
+		/// Attempted to construct a disjunction (or `andor`) for which none of the child node were strong
+		/// This means that a 3rd party could produce a satisfaction for any branch, meaning
+		/// that no matter which one an honest signer chooses, it is possible to malleate the transaction.
+		/// </summary>
+		NoStrongChild,
+
+
+
+		/// <summary>
+		/// Insufficiently many children of a threshold fragment were strong
+		/// </summary>
+		ThresholdNotStrong,
+
+		/// <summary>
+		/// Attempted to construct a wrapper, but the child had an invalid type
+		/// </summary>
+		ChildBase1,
+
+		/// <summary>
+		/// Attempted to construct a conjunction or disjunction
+		/// </summary>
+		ChildBase2,
+
+		/// <summary>
+		/// Attempted to construct an `andor` but the fragments
+		/// children were of invalid types
+		/// </summary>
+		ChildBase3,
+
+		/// <summary>
+		/// Tried to use the `s:` modifier on a fragment that takes more
+		/// than one input.
+		/// </summary>
+		SwapNonOne,
+
+		/// <summary>
+		/// Passed a `z` argument to a `d` wrapper when `z` was expected
+		/// </summary>
+		NonZeroDupIf,
+
+		/// <summary>
+		/// Tried to use `s:` modifier on a fragment that takes more than one input
+		/// </summary>
+		NonZeroZero,
+
+		/// <summary>
+		/// Many fragments (all disjunctions except `or_i` as well as
+		/// `andor`) require their left child be dissatisfiable.
+		/// </summary>
+		LeftNotDissatisfiable,
+
+		/// <summary>
+		/// `or_b` requires its right child be dissatisfiable
+		/// </summary>
+		RightNotDissatisfiable,
+
+		/// <summary>
+		/// Many fragments require their left child to be a unit. This
+		/// was not the case.
+		/// </summary>
+		LeftNotUnit,
+
+		/// <summary>
+		/// The nth child of a threshold fragment had an invalid type (the
+		/// first must be `B` and the rest `W`s)
+		/// </summary>
+		ThresholdBase,
+
+		/// <summary>
+		/// The nth child of a threshold fragment did not have a unique satisfaction
+		/// </summary>
+		ThresholdDissat,
+
+		/// <summary>
+		/// The nth child of a threshold fragment did not a unit.
+		/// </summary>
+		ThresholdNonUnit,
+	}
+	internal class FragmentPropertyException : Exception
+	{
+		public readonly ErrorKind Kind;
+		public FragmentPropertyException(string msg, Exception innerException): base(msg, innerException) {}
+		public FragmentPropertyException(string msg): base(msg) {}
+
+		internal FragmentPropertyException(ErrorKind kind, string msg, string fragment = null) : base($"Error in {fragment}\n {msg} . Kind:{kind.ToString("G")}")
+		{
+			Kind = kind;
+		}
+
+		public static FragmentPropertyException LeftNotUnit(string fragment = null) =>
+			new FragmentPropertyException (ErrorKind.LeftNotUnit, "this fragment requires left to be unit. But it was not.", fragment);
+
+		public static FragmentPropertyException  ChildBase1(Base b, string fragment = null) =>
+			new FragmentPropertyException (ErrorKind.ChildBase1, $"Attempted to construct a wrapper. But the child had an invalid type {b.ToString("G")}", fragment);
+		public static FragmentPropertyException  ChildBase2(Base l, Base r, string fragment = null) =>
+			new FragmentPropertyException (
+				ErrorKind.ChildBase2,
+				$"Attempted to construct a wrapper. But the child had an invalid type. left: {l.ToString("G")}. right: {r.ToString("G")}",
+				fragment
+				);
+
+		public static FragmentPropertyException  ChildBase3(Base a, Base b, Base c, string fragment = null) =>
+			new FragmentPropertyException (ErrorKind.ChildBase3, $"Attempted to construct a wrapper. But the child had an invalid type. a: {a.ToString("G")}. b: {b.ToString("G")}. c: {c.ToString("G")}", fragment);
+
+		public static FragmentPropertyException  SwapNoneOne(string fragment = null) =>
+			new FragmentPropertyException (ErrorKind.SwapNonOne, "Tried to use the s: modifier for the fragment takes more than one output.", fragment);
+
+		public static FragmentPropertyException  NonZeroDupIf(string fragment = null) =>
+			new FragmentPropertyException (ErrorKind.NonZeroDupIf, $"Passed a z argument to a d wrapper when `z` was expected.", fragment);
+
+		public static FragmentPropertyException  NonZeroZero(string fragment = null) =>
+			new FragmentPropertyException (ErrorKind.NonZeroZero, "Tried to use `s:` modifier on a fragment that takes more than one input", fragment);
+		public static FragmentPropertyException  LeftNotDissatisfiable(string fragment = null) =>
+			new FragmentPropertyException (ErrorKind.LeftNotDissatisfiable, "Left child must be dissatisfiable", fragment);
+		public static FragmentPropertyException  RightNotDissatisfiable(string fragment = null) =>
+			new FragmentPropertyException (ErrorKind.RightNotDissatisfiable, "Right child must be dissatisfiable.", fragment);
+
+		public static FragmentPropertyException  ThresholdBase(uint i, Base b, string fragment = null) =>
+			new FragmentPropertyException (ErrorKind.ThresholdBase,
+				$"the {i}th value of the threshold fragment had an invalid type {b} (first must be `B` and rest must be `W`.)", fragment);
+
+		public static FragmentPropertyException  ThresholdNonUnit(uint n, string fragment = null) =>
+			new FragmentPropertyException (ErrorKind.ThresholdNonUnit, $"the {n} th fragment of the threshold was not the unit", fragment);
+
+		public static FragmentPropertyException  ThresholdDissat(uint n, string fragment = null) =>
+			new FragmentPropertyException(ErrorKind.ThresholdDissat, $"the {n}th child of the threshold did not have unique satisfaction", fragment);
+
+		public static FragmentPropertyException ZeroThreshold(string fragment = null) =>
+			new FragmentPropertyException(ErrorKind.ZeroThreshold, "Multisignature or threshold policy had a `k` value of 0", fragment);
+
+		public static FragmentPropertyException OverThreshold(string fragment = null) =>
+			new FragmentPropertyException(
+				ErrorKind.OverThreshold,
+				"Multisignature or threshold policy has a `k` value in excess of the number of sub-fragments",
+				fragment);
+		public static FragmentPropertyException ZeroTime(string fragment = null) =>
+			new FragmentPropertyException(
+				ErrorKind.ZeroTime,
+				"Relative or absolute timelock had a time value of 0",
+				fragment);
+
+	}
+
+	internal static class FragmentPropertyExceptionExtension
+	{
+		internal static FragmentPropertyException Flatten(this List<FragmentPropertyException> es)
+			=> new FragmentPropertyException($"{es.Aggregate("", (acc, e) => acc + ", " + e)}");
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
new file mode 100644
index 0000000000..afd7d29966
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using NBitcoin.Scripting.Miniscript.Policy;
+
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+	internal abstract class IProperty<T> where T: IProperty<T>
+	{
+		public virtual void SanityChecks() {}
+
+		# region Casting operation
+		public abstract bool TryCastAlt(out T result, List<FragmentPropertyException> error);
+		public abstract bool TryCastSwap(out T result, List<FragmentPropertyException> error);
+		public abstract bool TryCastCheck(out T result, List<FragmentPropertyException> error);
+		public abstract bool TryCastDupIf(out T result, List<FragmentPropertyException> error);
+		public abstract bool TryCastVerify(out T result, List<FragmentPropertyException> error);
+		public abstract bool TryCastNonZero(out T result, List<FragmentPropertyException> error);
+		public abstract bool TryCastZeroNotEqual(out T result, List<FragmentPropertyException> error);
+		public abstract bool TryCastTrue(out T result, List<FragmentPropertyException> error);
+		public abstract bool TryCastOrIFalse(out T result, List<FragmentPropertyException> error);
+		public virtual bool TryCastLikely(out T result, List<FragmentPropertyException> error) => TryCastOrIFalse(out result, error);
+		public virtual bool TryCastUnLikely(out T result, List<FragmentPropertyException> error) => TryCastOrIFalse(out result, error);
+
+		#endregion
+
+		#region Constructors
+
+		// Technically These should work as static methods. But since there are no
+		// `abstract static` in C#, we create empty instance first and call these methods
+		// against those instance.
+		public abstract T FromTrue();
+		public abstract T FromFalse();
+		public abstract T FromPk();
+		public abstract T FromPkH();
+		public abstract T FromMulti(int k, int pkLength);
+		public abstract T FromHash();
+		public virtual T FromSha256() => this.FromHash();
+		public virtual T FromHash256() => this.FromHash();
+		public virtual T FromRipemd160() => this.FromHash();
+		public virtual T FromHash160() => this.FromHash();
+
+		public abstract T FromTime(uint time);
+		public virtual T FromAfter(uint time) => this.FromTime(time);
+		public virtual T FromOlder(uint time) => this.FromTime(time);
+
+
+		public abstract bool TryAndB(T l, T r, out T result, List<FragmentPropertyException> error);
+		public abstract bool TryAndV(T l, T r, out T result, List<FragmentPropertyException> error);
+		public virtual bool TryAndN(T l, T r, out T result, List<FragmentPropertyException> error)
+			=> TryAndOr(l, r, FromFalse(), out result, error);
+
+		public abstract bool TryOrB(T l, T r, out T result, List<FragmentPropertyException> error);
+		public abstract bool TryOrD(T l, T r, out T result, List<FragmentPropertyException> error);
+		public abstract bool TryOrC(T l, T r, out T result, List<FragmentPropertyException> error);
+		public abstract bool TryOrI(T l, T r, out T result, List<FragmentPropertyException> error);
+		public abstract bool TryAndOr(T a, T b, T c, out T result, List<FragmentPropertyException> error);
+
+		public delegate bool SubCk(int i, out T result, List<FragmentPropertyException> errors);
+		public abstract bool TryThreshold(int k, int n, SubCk subCk, out T result, List<FragmentPropertyException> error);
+		#endregion
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
new file mode 100644
index 0000000000..51fd605fc7
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -0,0 +1,290 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.Tracing;
+using NBitcoin.Scripting.Miniscript.Policy;
+
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+	/// <summary>
+	/// Whether the fragment has a dissatisfaction, and if so, whether it is unique.
+	/// Affects both correctness and malleability-freeness, since we assume 3rd parties
+	/// are able to produce dissatisfactions for all fragments.
+	/// </summary>
+	internal enum Dissat
+	{
+		/// <summary>
+		/// Fragment has no dissatisfaction and will abort given non-satisfying input
+		/// </summary>
+		None,
+		/// <summary>
+		/// Fragment has a unique dissatisfaction, which is always available.
+		/// </summary>
+		Unique,
+
+		/// <summary>
+		/// No assumptions may be made about dissatisfying this fragment. this
+		/// does not necessarily mean that there are multiple dissatisfactions;
+		/// There may be none, or none that are always available (e.g. for a `pk_h`
+		/// the key preimage may not be available.)
+		/// </summary>
+		Unknown
+	}
+
+	internal static class DissatExtension
+	{
+		internal static bool IsSubType(this Dissat self, Dissat other)
+		{
+			if (self == other) return true;
+			if (other == Dissat.Unknown) return true;
+			return false;
+		}
+
+		public static string DebugPrint(this Dissat self)
+			=> self == Dissat.None ? "f" :
+				self == Dissat.Unique ? "e" :
+				"";
+	}
+
+	internal class Malleability : IProperty<Malleability>
+	{
+		internal readonly Dissat Dissat;
+		internal readonly bool Safe;
+		internal readonly bool NonMalleable;
+
+		public Malleability(Dissat dissat, bool safe, bool nonMalleable)
+		{
+			Dissat = dissat;
+			Safe = safe;
+			NonMalleable = nonMalleable;
+		}
+
+		public Malleability() {}
+
+		internal bool IsSubtype(Malleability other) =>
+			Dissat.IsSubType(other.Dissat) &&
+				!(!this.Safe && other.Safe) &&
+				!(!NonMalleable && other.NonMalleable);
+
+		public override Malleability FromTrue() =>
+			new Malleability(Dissat.None, false, true);
+
+		public override Malleability FromFalse() =>
+			new Malleability(Dissat.Unique, true, true);
+
+		public override Malleability FromPk() =>
+			new Malleability(Dissat.Unique, true, true);
+
+		public override Malleability FromPkH() =>
+			new Malleability(Dissat.Unique, true, true);
+
+		public override Malleability FromMulti(int k, int pkLength) =>
+			new Malleability(Dissat.Unique, true,true);
+
+		public override Malleability FromTime(uint time) =>
+			new Malleability(Dissat.None, false, true);
+
+		public override Malleability FromHash() =>
+			new Malleability(Dissat.Unknown, false, true);
+
+		public override bool TryCastAlt(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = this;
+			return true;
+		}
+
+		public override bool TryCastSwap(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = this;
+			return true;
+		}
+
+		public override bool TryCastCheck(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = this;
+			return true;
+		}
+
+		public override bool TryCastDupIf(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result =
+			new Malleability(
+				(Dissat == Dissat.None ? Dissat.Unique : Dissat.Unknown),
+				Safe,
+				NonMalleable
+				);
+			return true;
+		}
+
+		public override bool TryCastVerify(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result =
+			new Malleability(
+				Dissat.None,
+				Safe,
+				NonMalleable
+			);
+			return true;
+		}
+
+		public override bool TryCastNonZero(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = new Malleability(
+				Dissat == Dissat.None ? Dissat.Unique : Dissat.Unknown,
+				Safe,
+				NonMalleable
+			);
+			return true;
+		}
+
+		public override bool TryCastZeroNotEqual(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = this;
+			return true;
+		}
+
+		public override bool TryCastTrue(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = new Malleability(
+				Dissat.None,
+				Safe,
+				NonMalleable
+			);
+			return true;
+		}
+
+		public override bool TryCastOrIFalse(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = new Malleability(
+				Dissat == Dissat.None ? Dissat.Unique : Dissat.Unknown,
+				Safe,
+				NonMalleable
+			);
+			return true;
+		}
+
+		public override bool TryAndB(Malleability left, Malleability right, out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = new Malleability(
+				(left.Dissat == Dissat.None && right.Dissat == Dissat.None) ||
+				(left.Dissat == Dissat.None && left.Safe) ||
+				(right.Dissat == Dissat.None && right.Safe)
+					? Dissat.None
+					:
+					(left.Dissat == Dissat.Unique && right.Dissat == Dissat.Unique && left.Safe && right.Safe)
+						?
+						Dissat.Unique
+						:
+						Dissat.Unknown,
+				left.Safe || right.Safe,
+				left.NonMalleable && right.NonMalleable
+			);
+			return true;
+		}
+
+
+		public override bool TryAndV(Malleability left, Malleability right, out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = new Malleability(
+				(left.Safe) || (right.Dissat == Dissat.None) ? Dissat.None : Dissat.Unknown,
+				left.Safe || right.Safe,
+				left.NonMalleable && right.NonMalleable
+			);
+			return true;
+		}
+
+		public override bool TryOrB(Malleability left, Malleability right, out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = new Malleability(
+				Dissat.Unique,
+				left.Safe && right.Safe,
+				left.NonMalleable
+				&& left.Dissat == Dissat.Unique
+				&& right.NonMalleable
+				&& right.Dissat == Dissat.Unique
+				&& (left.Safe || right.Safe)
+			);
+			return true;
+		}
+
+		public override bool TryOrD(Malleability left, Malleability right, out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = new Malleability(
+				right.Dissat,
+				left.Safe && right.Safe,
+				left.NonMalleable
+				&& left.Dissat == Dissat.Unique
+				&& right.NonMalleable
+				&& (left.Safe || right.Safe)
+			);
+			return true;
+		}
+
+
+		public override bool TryOrC(Malleability left, Malleability right, out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = new Malleability(
+				Dissat.None,
+				left.Safe && right.Safe,
+				left.NonMalleable
+				&& left.Dissat == Dissat.Unique
+				&& right.NonMalleable
+				&& (left.Safe || right.Safe)
+			);
+			return true;
+		}
+
+		public override bool TryOrI(Malleability left, Malleability right, out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = new Malleability(
+				(left.Dissat == Dissat.None && right.Dissat == Dissat.None) ? Dissat.None :
+				(left.Dissat == Dissat.Unique && right.Dissat == Dissat.None) ? Dissat.Unique :
+				(left.Dissat == Dissat.None && right.Dissat == Dissat.Unique) ? Dissat.Unique :
+				Dissat.Unknown,
+				left.Safe && right.Safe,
+				left.NonMalleable && right.NonMalleable && (left.Safe || right.Safe)
+			);
+			return true;
+		}
+
+		public override bool TryAndOr(Malleability a, Malleability b, Malleability c, out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = new Malleability(
+				(b.Dissat == Dissat.None && c.Dissat == Dissat.Unique) ? Dissat.Unique :
+				(a.Safe && c.Dissat == Dissat.Unique) ? Dissat.Unique :
+				(b.Dissat == Dissat.None && c.Dissat == Dissat.None) ? Dissat.None :
+				(a.Safe && c.Dissat == Dissat.None) ? Dissat.None :
+				Dissat.Unknown,
+				(a.Safe || b.Safe) && c.Safe,
+				a.NonMalleable
+				&& b.NonMalleable
+				&& c.NonMalleable
+				&& a.Dissat == Dissat.Unique
+				&& (a.Safe || b.Safe || c.Safe)
+			);
+			return true;
+		}
+
+		public override bool TryThreshold(int k, int n, SubCk ck, out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			var safeCount = 0;
+			var allAreDissatUnique = true;
+			var allAreNonMalleable = true;
+			for (int i = 0; i < n; i++)
+			{
+				if (!ck(i, out var subType, error))
+					return false;
+				safeCount += (subType.Safe ? 1 : 0);
+				allAreDissatUnique &= subType.Dissat == Dissat.Unique;
+				allAreNonMalleable &= subType.NonMalleable;
+			}
+			result = new Malleability(
+				allAreDissatUnique && (k == 1 || safeCount == n) ? Dissat.Unique : Dissat.Unknown,
+					safeCount > n - k,
+					allAreNonMalleable && safeCount >= n -k && (k == n || allAreDissatUnique)
+				);
+			return true;
+		}
+
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
new file mode 100644
index 0000000000..cfaf99ee59
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
@@ -0,0 +1,407 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using NBitcoin.Scripting.Miniscript.Policy;
+using Dissat = NBitcoin.Scripting.Miniscript.Types.Dissat;
+using Malleability = NBitcoin.Scripting.Miniscript.Types.Malleability;
+
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+	[DebuggerDisplay("{" + nameof(DebugPrint) + "()}")]
+	internal class MiniscriptFragmentType : IProperty<MiniscriptFragmentType>, IEquatable<MiniscriptFragmentType>
+	{
+		internal readonly Correctness Correctness;
+
+		internal readonly Malleability Malleability;
+
+		private MiniscriptFragmentType(Correctness correctness, Malleability malleability)
+		{
+			Correctness = correctness;
+			Malleability = malleability;
+		}
+
+		public MiniscriptFragmentType() {}
+
+		public bool IsSubtype(MiniscriptFragmentType other) =>
+			Correctness.IsSubtype(other.Correctness) &&
+			Malleability.IsSubtype(other.Malleability);
+
+		public override void SanityChecks()
+		{
+			Debug.Assert(
+				(!this.Correctness.DisSatisfiable || this.Malleability.Dissat != Dissat.None) &&
+				(this.Malleability.Dissat == Dissat.None || this.Correctness.Base != Base.V) &&
+				(this.Malleability.Safe || this.Correctness.Base != Base.K) &&
+				(this.Malleability.NonMalleable || this.Correctness.Input != Input.Zero), this.DebugPrint());
+		}
+
+		internal string DebugPrint()
+			=> $"Correctness: {Correctness.DebugPrint()}. is safe?: {Malleability.Safe}. is non malleable?: {Malleability.NonMalleable}";
+
+		public override MiniscriptFragmentType FromTrue()
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().FromTrue(),
+				new Malleability().FromTrue());
+
+		public override MiniscriptFragmentType FromFalse() =>
+			new MiniscriptFragmentType(
+				new Correctness().FromFalse(),
+				new Malleability().FromFalse());
+
+		public override MiniscriptFragmentType FromPk()
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().FromPk(),
+				new Malleability().FromPk());
+
+		public override MiniscriptFragmentType FromPkH()
+			=>
+			new MiniscriptFragmentType(new Correctness().FromPkH(), new Malleability().FromPkH());
+
+		public override MiniscriptFragmentType FromMulti(int k, int pkLength)
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().FromMulti(k, pkLength),
+				new Malleability().FromMulti(k, pkLength));
+
+		public override MiniscriptFragmentType FromTime(uint time) =>
+			new MiniscriptFragmentType(
+				new Correctness().FromTime(time),
+				new Malleability().FromTime(time)
+				);
+
+		public override MiniscriptFragmentType FromAfter(uint time)
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().FromAfter(time),
+				new Malleability().FromAfter(time));
+
+		public override MiniscriptFragmentType FromOlder(uint time)
+			=> new MiniscriptFragmentType(
+				new Correctness().FromOlder(time),
+				new Malleability().FromOlder(time));
+
+		public override MiniscriptFragmentType FromHash()
+			=>
+
+			new MiniscriptFragmentType(
+				new Correctness().FromHash(),
+				new Malleability().FromHash());
+
+		public override MiniscriptFragmentType FromSha256()
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().FromSha256(),
+				new Malleability().FromSha256());
+
+		public override MiniscriptFragmentType FromHash256()
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().FromHash256(),
+				new Malleability().FromHash256());
+
+		public override MiniscriptFragmentType FromRipemd160()
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().FromRipemd160(),
+				new Malleability().FromRipemd160());
+
+		public override MiniscriptFragmentType FromHash160()
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().FromHash160(),
+				new Malleability().FromHash160());
+
+		public override bool TryCastAlt(out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (Correctness.TryCastAlt(out var corr, error) && Malleability.TryCastAlt(out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+		public override bool TryCastSwap(out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (Correctness.TryCastSwap(out var corr, error) && Malleability.TryCastSwap(out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+		public override bool TryCastCheck(out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (Correctness.TryCastCheck(out var corr, error) && Malleability.TryCastCheck(out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+		public override bool TryCastDupIf(out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (Correctness.TryCastDupIf(out var corr, error) && Malleability.TryCastDupIf(out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+		public override bool TryCastVerify(out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (Correctness.TryCastVerify(out var corr, error) && Malleability.TryCastVerify(out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+		public override bool TryCastNonZero(out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (Correctness.TryCastNonZero(out var corr, error) && Malleability.TryCastNonZero(out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+		public override bool TryCastZeroNotEqual(out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (Correctness.TryCastZeroNotEqual(out var corr, error) && Malleability.TryCastZeroNotEqual(out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+
+		public override bool TryCastTrue(out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (Correctness.TryCastTrue(out var corr, error) && Malleability.TryCastTrue(out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+		public override bool TryCastOrIFalse(out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (Correctness.TryCastOrIFalse(out var corr, error) && Malleability.TryCastOrIFalse(out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+		public override bool TryCastUnLikely(out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (Correctness.TryCastUnLikely(out var corr, error) && Malleability.TryCastUnLikely(out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+		public override bool TryCastLikely(out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (Correctness.TryCastLikely(out var corr, error) && Malleability.TryCastLikely(out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+
+		public override bool TryAndB(MiniscriptFragmentType left, MiniscriptFragmentType right,
+			out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (new Correctness().TryAndB(left.Correctness, right.Correctness,out var corr, error)
+			    && new Malleability().TryAndB(left.Malleability, right.Malleability , out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+		public override bool TryAndV(MiniscriptFragmentType left, MiniscriptFragmentType right, out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (new Correctness().TryAndV(left.Correctness, right.Correctness,out var corr, error)
+			    && new Malleability().TryAndV(left.Malleability, right.Malleability , out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+
+		public override bool TryOrB(MiniscriptFragmentType left, MiniscriptFragmentType right, out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (new Correctness().TryOrB(left.Correctness, right.Correctness,out var corr, error)
+			    && new Malleability().TryOrB(left.Malleability, right.Malleability , out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+		public override bool TryOrD(MiniscriptFragmentType left, MiniscriptFragmentType right, out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (new Correctness().TryOrD(left.Correctness, right.Correctness,out var corr, error)
+			    && new Malleability().TryOrD(left.Malleability, right.Malleability , out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+
+		public override bool TryOrC(MiniscriptFragmentType left, MiniscriptFragmentType right, out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (new Correctness().TryOrC(left.Correctness, right.Correctness,out var corr, error)
+			    && new Malleability().TryOrC(left.Malleability, right.Malleability , out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+
+		public override bool TryOrI(MiniscriptFragmentType left, MiniscriptFragmentType right, out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (new Correctness().TryOrI(left.Correctness, right.Correctness,out var corr, error)
+			    && new Malleability().TryOrI(left.Malleability, right.Malleability , out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+
+		public override bool TryAndOr(MiniscriptFragmentType a, MiniscriptFragmentType b, MiniscriptFragmentType c, out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (new Correctness().TryAndOr(a.Correctness, b.Correctness,c.Correctness, out var corr, error)
+			    && new Malleability().TryAndOr(a.Malleability, b.Malleability, c.Malleability, out var mall, error))
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+
+			return false;
+		}
+
+
+
+		public override bool TryThreshold(int k, int n, SubCk subCk,
+			out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			IProperty<Correctness>.SubCk getSubCorrectness =
+				(int i, out Correctness subCorr, List<FragmentPropertyException> list) =>
+				{
+					subCorr = null;
+					if (subCk(i, out var subResult, error))
+					{
+						subCorr = subResult.Correctness;
+						return true;
+					}
+					return false;
+				};
+			IProperty<Malleability>.SubCk getSubMalleability =
+				(int i, out Malleability subMall, List<FragmentPropertyException> list) =>
+				{
+					subMall = null;
+					if (subCk(i, out var subResult, error))
+					{
+						subMall = subResult.Malleability;
+						return true;
+					}
+					return false;
+				};
+			if (new Correctness().TryThreshold(k, n, getSubCorrectness, out var corr, error)
+			    && new Malleability().TryThreshold(k, n, getSubMalleability, out var mall, error)
+			)
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+			return false;
+		}
+
+
+		public override bool Equals(object obj) => Equals(obj as MiniscriptFragmentType);
+		public bool Equals(MiniscriptFragmentType other)
+			=> (!(other is null))
+				&& (Correctness.Base == other.Correctness.Base)
+				&& (Correctness.Input == other.Correctness.Input)
+				&& (Correctness.DisSatisfiable == other.Correctness.DisSatisfiable)
+				&& (Correctness.Unit == other.Correctness.Unit)
+				&& (Malleability.Dissat == other.Malleability.Dissat)
+				&& (Malleability.NonMalleable == other.Malleability.NonMalleable)
+				&& (Malleability.Safe == other.Malleability.Safe);
+
+		public override int GetHashCode()
+		{
+			int num = 0;
+			num = -1640531527 + Correctness.Base.GetHashCode() + ((num << 6) + (num >> 2));
+			num = -1640531527 + Correctness.Input.GetHashCode() + ((num << 6) + (num >> 2));
+			num = -1640531527 + Correctness.DisSatisfiable.GetHashCode() + ((num << 6) + (num >> 2));
+			num = -1640531527 + Correctness.Unit.GetHashCode() + ((num << 6) + (num >> 2));
+			num = -1640531527 + Malleability.Dissat.GetHashCode() + ((num << 6) + (num >> 2));
+			num = -1640531527 + Malleability.NonMalleable.GetHashCode() + ((num << 6) + (num >> 2));
+			num = -1640531527 + Malleability.Safe.GetHashCode() + ((num << 6) + (num >> 2));
+			return num;
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/Property.cs b/NBitcoin/Scripting/Miniscript/Types/Property.cs
new file mode 100644
index 0000000000..3167272cf1
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/Property.cs
@@ -0,0 +1,186 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using NBitcoin.Scripting.Miniscript.Policy;
+
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+	internal static class Property<T, TPk, TPKh>
+	where T : IProperty<T>, new()
+	where TPk : class, IMiniscriptKey<TPKh>, new()
+	where TPKh : class, IMiniscriptKeyHash, new()
+	{
+
+		/// <summary>
+		/// Compute the type of a fragment, given a function to look up
+		/// the types of its children, if available and relevant for the
+		/// given fragment.
+		/// </summary>
+		internal static bool TryTypeCheck(Terminal<TPk, TPKh> fragment, Func<int, T> child, out T res, List<FragmentPropertyException> errors)
+		{
+			if (TryTypeCheckCore(fragment, child, out res, errors))
+			{
+				res.SanityChecks();
+				return true;
+			}
+			return false;
+		}
+
+		internal static bool TypeCheck(Terminal<TPk, TPKh> fragment, out T res, List<FragmentPropertyException> errors)
+			=> TryTypeCheck(fragment, (_) => null, out res, errors);
+
+		private static bool TryTypeCheckCore(Terminal<TPk, TPKh> fragment,Func<int, T> child, out T result, List<FragmentPropertyException> errors)
+		{
+			result = null;
+			if (fragment is null)
+				throw new ArgumentNullException(nameof(fragment));
+
+			bool TryGetChild(Terminal<TPk, TPKh> sub, int n, out T subResult)
+				{
+						var r = child(n);
+						if (r is null)
+							return TryTypeCheck(sub, _ => null, out subResult, errors);
+						subResult = r;
+						return true;
+				}
+
+			switch (fragment.Tag)
+			{
+				case Terminal<TPk, TPKh>.Tags.True:
+					result = new T().FromTrue();
+					return true;
+				case Terminal<TPk, TPKh>.Tags.False:
+					result = new T().FromFalse();
+					return true;
+			}
+
+			switch (fragment)
+			{
+				case Terminal<TPk, TPKh>.Pk self:
+					result = new T().FromPk();
+					return true;
+				case Terminal<TPk, TPKh>.PkH self:
+					result = new T().FromPkH();
+					return true;
+				case Terminal<TPk, TPKh>.ThreshM self:
+					if (self.Item1 == 0)
+					{
+						errors.Add(FragmentPropertyException.ZeroThreshold(fragment.ToString()));
+						return false;
+					}
+
+					if (self.Item1 > self.Item2.Length)
+					{
+						errors.Add(FragmentPropertyException.OverThreshold(
+							fragment.ToString()
+						));
+						return false;
+					}
+					result = new T().FromMulti((int)self.Item1, self.Item2.Length);
+					return true;
+				case Terminal<TPk, TPKh>.After self:
+					if (self.Item == 0)
+					{
+						errors.Add(FragmentPropertyException.ZeroTime(fragment.ToString()));
+						return false;
+					}
+
+					result = new T().FromAfter(self.Item);
+					return true;
+				case Terminal<TPk, TPKh>.Older self:
+					if (self.Item == 0)
+					{
+						errors.Add(FragmentPropertyException.ZeroTime(fragment.ToString()));
+						return false;
+					}
+
+					result = new T().FromOlder(self.Item);
+					return true;
+				case Terminal<TPk, TPKh>.Sha256 self:
+					result = new T().FromSha256();
+					return true;
+				case Terminal<TPk, TPKh>.Hash256 self:
+					result = new T().FromHash256();
+					return true;
+				case Terminal<TPk, TPKh>.Ripemd160 self:
+					result = new T().FromRipemd160();
+					return true;
+				case Terminal<TPk, TPKh>.Hash160 self:
+					result = new T().FromHash160();
+					return true;
+				case Terminal<TPk, TPKh>.Alt self:
+					return (TryGetChild(self.Item.Node, 0, out var subAlt) && subAlt.TryCastAlt(out result, errors));
+				case Terminal<TPk, TPKh>.Swap self:
+					return (TryGetChild(self.Item.Node, 0, out var subSwap) && subSwap.TryCastSwap(out result, errors));
+				case Terminal<TPk, TPKh>.Check self:
+					return (TryGetChild(self.Item.Node, 0, out var subCheck) && subCheck.TryCastCheck(out result, errors));
+				case Terminal<TPk, TPKh>.DupIf self:
+					return (TryGetChild(self.Item.Node, 0, out var subDupIf) && subDupIf.TryCastDupIf(out result, errors));
+				case Terminal<TPk, TPKh>.Verify self:
+					return (TryGetChild(self.Item.Node, 0, out var subVerify) &&
+					        subVerify.TryCastVerify(out result, errors));
+				case Terminal<TPk, TPKh>.NonZero self:
+					return (TryGetChild(self.Item.Node, 0, out var subNonZero) &&
+					        subNonZero.TryCastNonZero(out result, errors));
+				case Terminal<TPk, TPKh>.ZeroNotEqual self:
+					return (TryGetChild(self.Item.Node, 0, out var sub0NotEqual) &&
+					        sub0NotEqual.TryCastZeroNotEqual(out result, errors));
+				case Terminal<TPk, TPKh>.AndB self:
+					return (TryGetChild(self.Item1.Node, 0, out var andBL)
+						&& TryGetChild(self.Item2.Node, 1, out var andBR)
+						&& new T().TryAndB(andBL, andBR, out result, errors)) ;
+				case Terminal<TPk, TPKh>.AndV self:
+					return
+						TryGetChild(self.Item1.Node, 0, out var andVL)
+						&& TryGetChild(self.Item2.Node, 1, out var andVR)
+						&& new T().TryAndV(andVL, andVR, out result, errors);
+				case Terminal<TPk, TPKh>.OrB self:
+					return
+						TryGetChild(self.Item1.Node, 0, out var orBL)
+						&& TryGetChild(self.Item2.Node, 1, out var orBR)
+						&& new T().TryOrB(orBL, orBR, out result, errors);
+				case Terminal<TPk, TPKh>.OrD self:
+					return
+						TryGetChild(self.Item1.Node, 0, out var orDL)
+						&& TryGetChild(self.Item2.Node, 1, out var orDR)
+						&& new T().TryOrD(orDL, orDR, out result, errors);
+				case Terminal<TPk, TPKh>.OrC self:
+					return
+						TryGetChild(self.Item1.Node, 0, out var orCL)
+						&& TryGetChild(self.Item2.Node, 1, out var orCR)
+						&& new T().TryOrC(orCL, orCR, out result, errors);
+				case Terminal<TPk, TPKh>.OrI self:
+					return
+						TryGetChild(self.Item1.Node, 0, out var orIL)
+						&& TryGetChild(self.Item2.Node, 1, out var orIR)
+						&& new T().TryOrI(orIL, orIR, out result, errors);
+				case Terminal<TPk, TPKh>.AndOr self:
+					return
+						TryGetChild(self.Item1.Node, 0, out var a)
+						&& TryGetChild(self.Item2.Node, 1, out var b)
+						&& TryGetChild(self.Item3.Node, 2, out var c)
+						&& new T().TryAndOr(a, b, c, out result, errors);
+				case Terminal<TPk, TPKh>.Thresh self:
+					if (self.Item1 == 0)
+					{
+						errors.Add(FragmentPropertyException.ZeroThreshold(fragment.ToString()));
+						return false;
+					}
+
+					if (self.Item1 > self.Item2.Length)
+					{
+						errors.Add(FragmentPropertyException.OverThreshold(fragment.ToString()));
+						return false;
+					}
+
+					IProperty<T>.SubCk subCk =
+						(int i, out T property, List<FragmentPropertyException> list) => (TryGetChild(self.Item2[i].Node, i, out property));
+
+					return (new T().TryThreshold(
+						(int) self.Item1,
+						self.Item2.Length, subCk, out result, errors));
+			}
+			throw new Exception($"Unreachable! {fragment}");;
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Utils.cs b/NBitcoin/Scripting/Miniscript/Utils.cs
new file mode 100644
index 0000000000..dcc761b9d8
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Utils.cs
@@ -0,0 +1,22 @@
+namespace NBitcoin.Scripting.Miniscript
+{
+	internal static class Utils
+	{
+		internal static int ScriptNumSize(int n) => ScriptNumSize((ulong)n);
+		internal static int ScriptNumSize(ulong n)
+		{
+			if (n <= 0x10) // OP_n
+				return 1;
+			if (n < 0x80) // OP_PUSH1 <n>
+				return 2;
+			if (n < 0x8000) // OP_PUSH2 <n>
+				return 3;
+			if (n < 0x800000) // OP_PUSH3 <n>
+				return 4;
+			if (n < 0x80000000) // OP_PUSH4 <n>
+				return 5;
+
+			return 6; // OP_PUSH5 <n>
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Parser/Parse.ScriptToken.cs b/NBitcoin/Scripting/Parser/Parse.ScriptToken.cs
index 1f8e9309e5..78c74cd9ac 100644
--- a/NBitcoin/Scripting/Parser/Parse.ScriptToken.cs
+++ b/NBitcoin/Scripting/Parser/Parse.ScriptToken.cs
@@ -1,30 +1,46 @@
-using System;
-
-namespace NBitcoin.Scripting.Parser
-{
-	internal static partial class Parse
-	{
-		public static Parser<ScriptToken, ScriptToken> ScriptToken(Func<int, bool> predicate, string expected)
-		{
-			return i =>
-			{
-				if (i.AtEnd)
-				{
-					return ParserResult<ScriptToken, ScriptToken>.Failure(i, new[] { expected }, "Unexpected end of input");
-				}
-
-				if (predicate(i.GetCurrent().Tag))
-					return ParserResult<ScriptToken, ScriptToken>.Success(i.Advance(), i.GetCurrent());
-				return ParserResult<ScriptToken, ScriptToken>.Failure(i, $"Unexpected {i.GetCurrent()}");
-			};
-		}
-
-		public static Parser<ScriptToken, ScriptToken> ScriptToken(ScriptToken sct, string expected)
-			=> ScriptToken((tag) => tag == sct.Tag, expected);
-
-		public static Parser<ScriptToken, ScriptToken> ScriptToken(int tag)
-			=> ScriptToken(actualTag => actualTag == tag, $"ScriptToken for tag: {tag}");
-		public static Parser<ScriptToken, ScriptToken> ScriptToken(ScriptToken sct)
-			=> ScriptToken(sct, sct.ToString());
-	}
-}
\ No newline at end of file
+using System;
+using NBitcoin.Scripting.Miniscript;
+
+namespace NBitcoin.Scripting.Parser
+{
+	internal static partial class Parse
+	{
+		public static Parser<ScriptToken, ScriptToken> ScriptToken(Func<int, bool> predicate, string expected)
+		{
+			return i =>
+			{
+				if (i.AtEnd)
+				{
+					return ParserResult<ScriptToken, ScriptToken>.Failure(i, new[] { expected }, "Unexpected end of input");
+				}
+
+				if (predicate(i.GetCurrent().Tag))
+					return ParserResult<ScriptToken, ScriptToken>.Success(i.Advance(), i.GetCurrent());
+				return ParserResult<ScriptToken, ScriptToken>.Failure(i, $"Unexpected {i.GetCurrent()}");
+			};
+		}
+
+		public static Parser<ScriptToken, T> ScriptToken<T>()
+		=> i =>
+			{
+				var expected = typeof(T).Name;
+				if (i.AtEnd)
+				{
+					return ParserResult<ScriptToken, T>.Failure(i, new[] { expected }, "Unexpected end of input");
+				}
+				var curr = i.GetCurrent();
+				if (curr is T ti)
+					return ParserResult<ScriptToken, T>.Success(i.Advance(), ti);
+				return ParserResult<ScriptToken, T>.Failure(i, $"Unexpected {curr}");
+			};
+
+		public static Parser<ScriptToken, ScriptToken> ScriptToken(ScriptToken sct, string expected)
+			=> ScriptToken((tag) => tag == sct.Tag, expected);
+
+		public static Parser<ScriptToken, ScriptToken> ScriptToken(int tag)
+			=> ScriptToken(actualTag => actualTag == tag, $"ScriptToken for tag: {tag}");
+
+		public static Parser<ScriptToken, ScriptToken> ScriptToken(ScriptToken sct)
+			=> ScriptToken(sct, sct.ToString());
+	}
+}
diff --git a/NBitcoin/Scripting/Parser/Parse.cs b/NBitcoin/Scripting/Parser/Parse.cs
index cd1c9a8caf..ce193e3372 100644
--- a/NBitcoin/Scripting/Parser/Parse.cs
+++ b/NBitcoin/Scripting/Parser/Parse.cs
@@ -1,655 +1,655 @@
-using System.Linq;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-
-namespace NBitcoin.Scripting.Parser
-{
-	internal static partial class Parse
-	{
-
-
-		public static Parser<TToken, U> Then<TToken, T, U>(this Parser<TToken, T> first, Func<T, Parser<TToken, U>> second)
-		{
-			if (first == null)
-				throw new ArgumentNullException(nameof(first));
-			if (second == null)
-				throw new ArgumentNullException(nameof(second));
-
-			return i => first(i).IfSuccess(s => second(s.Value)(s.Rest));
-		}
-
-		public static Parser<TToken, IEnumerable<T>> Many<TToken, T>(this Parser<TToken, T> parser)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-
-			return i =>
-			{
-				var rest = i;
-				var result = new List<T>();
-				var r = parser(i);
-				while (r.IsSuccess)
-				{
-					if (rest.Equals(r.Rest))
-						break;
-					result.Add(r.Value);
-					rest = r.Rest;
-					r = parser(rest);
-				}
-
-				return ParserResult<TToken, IEnumerable<T>>.Success(rest, result);
-			};
-		}
-
-		/// <summary>
-		/// Parse a stream of elements, failing if any element is only partially parsed.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T">The type of element to parse.</typeparam>
-		/// <param name="parser">A parser that matches a single element.</param>
-		/// <returns>A <see cref="Parser{T}"/> that matches the sequence.</returns>
-		/// <remarks>
-		/// <para>
-		/// Using <seealso cref="XMany{TToken, T}(Parser{TToken, T})"/> may be preferable to <seealso cref="Many{TToken, T}(Parser{TToken, T})"/>
-		/// where the first character of each match identified by <paramref name="parser"/>
-		/// is sufficient to determine whether the entire match should succeed. The X*
-		/// methods typically give more helpful errors and are easier to debug than their
-		/// unqualified counterparts.
-		/// </para>
-		/// </remarks>
-		/// <seealso cref="XOr"/>
-		public static Parser<TToken, IEnumerable<T>> XMany<TToken, T>(this Parser<TToken, T> parser)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-
-			return parser.Many<TToken, T>().Then(m => parser.Once().XOr(Return<TToken, IEnumerable<T>>(m)));
-		}
-
-		/// <summary>
-		/// TryParse a stream of elements with at least one item.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="parser"></param>
-		/// <returns></returns>
-		public static Parser<TToken, IEnumerable<T>> AtLeastOnce<TToken, T>(this Parser<TToken, T> parser)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-
-			return parser.Once().Then(t1 => parser.Many().Select(ts => t1.Concat(ts)));
-		}
-
-		public static Parser<TToken, IEnumerable<T>> Once<TToken, T>(this Parser<TToken, T> parser)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-			return parser.Select(r => (IEnumerable<T>)new[] { r });
-		}
-
-		public static Parser<TToken, IEnumerable<T>> AtLeastOne<TToken, T>(this Parser<TToken, T> parser)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-
-			return parser.Once().Then(t1 => parser.Many().Select(ts => t1.Concat(ts)));
-		}
-
-		/// <summary>
-		/// TryParse a stream of elements with at least one item. Except the first
-		/// item, all other items will be matched with the <code>XMany</code> operator.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="parser"></param>
-		/// <returns></returns>
-		public static Parser<TToken, IEnumerable<T>> XAtLeastOnce<TToken, T>(this Parser<TToken, T> parser)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-
-			return parser.Once().Then(t1 => parser.XMany().Select(ts => t1.Concat(ts)));
-		}
-
-		/// <summary>
-		/// Lift to a parser monad world
-		/// </summary>
-		/// <param name="v"></param>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <returns></returns>
-		public static Parser<TToken, T> Return<TToken, T>(T v)
-			=> i => ParserResult<TToken, T>.Success(i, v);
-
-		/// <summary>
-		/// Take the result of parsing, and project it onto a different domain.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <typeparam name="U"></typeparam>
-		/// <param name="parser"></param>
-		/// <param name="convert"></param>
-		/// <returns></returns>
-		public static Parser<TToken, U> Select<TToken, T, U>(this Parser<TToken, T> parser, Func<T, U> convert)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-			if (convert == null)
-				throw new ArgumentNullException(nameof(convert));
-
-			return parser.Then(t => Return<TToken, U>(convert(t)));
-		}
-
-		public static Parser<TToken, IEnumerable<T>> Sequence<TToken, T>(this IEnumerable<Parser<TToken, T>> parserList)
-		{
-			return
-				parserList
-					.Aggregate(Return<TToken, IEnumerable<T>>(Enumerable.Empty<T>()), (a, p) => a.Concat(p.Once()));
-		}
-
-		/// <summary>
-		/// Refer to another parser indirectly. This allows circular compile-time dependency between parsers.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="reference"></param>
-		/// <returns></returns>
-		public static Parser<TToken, T> Ref<TToken, T>(Func<Parser<TToken, T>> reference)
-		{
-			if (reference == null)
-				throw new ArgumentNullException(nameof(reference));
-
-			Parser<TToken, T> p = null;
-
-			return i =>
-				{
-					if (p == null)
-						p = reference();
-
-					if (i.Memos.ContainsKey(p))
-						throw new ParsingException(i.Memos[p].ToString());
-
-					i.Memos[p] = ParserResult<TToken, T>.Failure(i,
-						new string[0],
-						"Left recursion in the grammar."
-					);
-					var result = p(i);
-					i.Memos[p] = result;
-					return result;
-				};
-		}
-
-
-		public static Parser<TToken, T> Or<TToken, T>(this Parser<TToken, T> first, Parser<TToken, T> second)
-		{
-			if (first == null)
-				throw new ArgumentNullException(nameof(first));
-			if (second == null)
-				throw new ArgumentNullException(nameof(second));
-
-			return i =>
-			{
-				var fr = first(i);
-				if (!fr.IsSuccess)
-					return second(i).IfFailure<T>(sf => DetermineBestError(fr, sf));
-
-				if (fr.Rest.Equals(i))
-					return second(i).IfFailure<T>(sf => fr);
-
-				return fr;
-			};
-		}
-
-
-		/// <summary>
-		/// Parse first, if it succeeds, return first, otherwise try second.
-		/// Assumes that the first parsed character will determine the parser chosen (see Try).
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="first"></param>
-		/// <param name="second"></param>
-		/// <returns></returns>
-		public static Parser<TToken, T> XOr<TToken, T>(this Parser<TToken, T> first, Parser<TToken, T> second)
-		{
-			if (first == null)
-				throw new ArgumentNullException(nameof(first));
-			if (second == null)
-				throw new ArgumentNullException(nameof(second));
-
-			return i =>
-			{
-				var fr = first(i);
-				if (!fr.IsSuccess)
-				{
-					// The 'X' part
-					if (!fr.Rest.Equals(i))
-						return fr;
-
-					return second(i).IfFailure<T>(sf => DetermineBestError(fr, sf));
-				}
-
-				// This handles a zero-length successful application of first.
-				if (fr.Rest.Equals(i))
-					return second(i).IfFailure<T>(sf => fr);
-
-				return fr;
-			};
-		}
-
-		/// <summary>
-		/// Concatenate two streams of elements.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="first"></param>
-		/// <param name="second"></param>
-		/// <returns></returns>
-		public static Parser<TToken, IEnumerable<T>> Concat<TToken, T>(this Parser<TToken, IEnumerable<T>> first, Parser<TToken, IEnumerable<T>> second)
-		{
-			if (first == null)
-				throw new ArgumentNullException(nameof(first));
-			if (second == null)
-				throw new ArgumentNullException(nameof(second));
-
-			return first.Then(f => second.Select(f.Concat));
-		}
-
-		public static ParserResult<TToken, T> DetermineBestError<TToken, T>(
-			ParserResult<TToken, T> firstF,
-			ParserResult<TToken, T> secondF
-			)
-		{
-			if (secondF.Rest.Position > firstF.Rest.Position)
-				return secondF;
-
-			if (secondF.Rest.Position == firstF.Rest.Position)
-				return ParserResult<TToken, T>.Failure(
-					firstF.Rest,
-					firstF.Expected.Union(secondF.Expected),
-					firstF.Description
-				);
-
-			return firstF;
-		}
-
-
-		/// <summary>
-		/// Version of Return with simpler inline syntax.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <typeparam name="U"></typeparam>
-		/// <param name="parser"></param>
-		/// <param name="value"></param>
-		/// <returns></returns>
-		public static Parser<TToken, U> Return<TToken, T, U>(this Parser<TToken, T> parser, U value)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-			return parser.Select(t => value);
-		}
-
-
-		/// <summary>
-		/// Attempt parsing only if the <paramref name="except"/> parser fails.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <typeparam name="U"></typeparam>
-		/// <param name="parser"></param>
-		/// <param name="except"></param>
-		/// <returns></returns>
-		public static Parser<TToken, T> Except<TToken, T, U>(this Parser<TToken, T> parser, Parser<TToken, U> except)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-			if (except == null)
-				throw new ArgumentNullException(nameof(except));
-
-			// Could be more like: except.Then(s => s.Fail("..")).XOr(parser)
-			return i =>
-				{
-					var r = except(i);
-					if (r.IsSuccess)
-						return ParserResult<TToken, T>.Failure(i, new[] { "other than the excepted input" }, "Excepted parser succeeded.");
-					return parser(i);
-				};
-		}
-
-		public static Parser<TToken, T> End<TToken, T>(this Parser<TToken, T> parser)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-
-			return i => parser(i).IfSuccess(s =>
-				s.Rest.AtEnd ? s : ParserResult<TToken, T>.Failure(
-					s.Rest,
-					new[] { "end of input" },
-					string.Format("unexpected '{0}'", s.Rest.GetCurrent())
-				)
-			);
-		}
-		/// <summary>
-		/// Parse a sequence of items until a terminator is reached.
-		/// Returns the sequence, discarding the terminator.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <typeparam name="U"></typeparam>
-		/// <param name="parser"></param>
-		/// <param name="until"></param>
-		/// <returns></returns>
-		public static Parser<TToken, IEnumerable<T>> Until<TToken, T, U>(this Parser<TToken, T> parser, Parser<TToken, U> until)
-		{
-			return parser.Except(until).Many().Then(r => until.Return(r));
-		}
-
-
-		/// <summary>
-		/// Succeed if the parsed value matches predicate.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="parser"></param>
-		/// <param name="predicate"></param>
-		/// <returns></returns>
-		public static Parser<TToken, T> Where<TToken, T>(this Parser<TToken, T> parser, Func<T, bool> predicate)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-			if (predicate == null)
-				throw new ArgumentNullException(nameof(predicate));
-
-			return i => parser(i).IfSuccess(s =>
-				predicate(s.Value) ? s : ParserResult<TToken, T>.Failure(i,
-					new string[0],
-					string.Format("Unexpected {0}.", s.Value)
-					)
-				);
-		}
-
-
-		/// <summary>
-		/// Monadic combinator Then, adapted for Linq comprehension syntax.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <typeparam name="U"></typeparam>
-		/// <typeparam name="V"></typeparam>
-		/// <param name="parser"></param>
-		/// <param name="selector"></param>
-		/// <param name="projector"></param>
-		/// <returns></returns>
-		public static Parser<TToken, V> SelectMany<TToken, T, U, V>(
-			this Parser<TToken, T> parser,
-			Func<T, Parser<TToken, U>> selector,
-			Func<T, U, V> projector)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-			if (selector == null)
-				throw new ArgumentNullException(nameof(selector));
-			if (projector == null)
-				throw new ArgumentNullException(nameof(projector));
-
-			return parser.Then(t => selector(t).Select(u => projector(t, u)));
-		}
-
-		public static Parser<TToken, U> Bind<TToken, T, U>(
-			this Parser<TToken, T> parser,
-			Func<T, Parser<TToken, U>> selector
-		)
-			=> parser.SelectMany(selector, (t, u) => u);
-
-		/// <summary>
-		/// Chain a left-associative operator.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <typeparam name="TOp"></typeparam>
-		/// <param name="op"></param>
-		/// <param name="operand"></param>
-		/// <param name="apply"></param>
-		/// <returns></returns>
-		public static Parser<TToken, T> ChainOperator<TToken, T, TOp>(
-			Parser<TToken, TOp> op,
-			Parser<TToken, T> operand,
-			Func<TOp, T, T, T> apply)
-		{
-			if (op == null)
-				throw new ArgumentNullException(nameof(op));
-			if (operand == null)
-				throw new ArgumentNullException(nameof(operand));
-			if (apply == null)
-				throw new ArgumentNullException(nameof(apply));
-			return operand.Then(first => ChainOperatorRest(first, op, operand, apply, Or));
-		}
-
-		/// <summary>
-		/// Chain a left-associative operator.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <typeparam name="TOp"></typeparam>
-		/// <param name="op"></param>
-		/// <param name="operand"></param>
-		/// <param name="apply"></param>
-		/// <returns></returns>
-		public static Parser<TToken, T> XChainOperator<TToken, T, TOp>(
-			Parser<TToken, TOp> op,
-			Parser<TToken, T> operand,
-			Func<TOp, T, T, T> apply)
-		{
-			if (op == null)
-				throw new ArgumentNullException(nameof(op));
-			if (operand == null)
-				throw new ArgumentNullException(nameof(operand));
-			if (apply == null)
-				throw new ArgumentNullException(nameof(apply));
-			return operand.Then(first => ChainOperatorRest(first, op, operand, apply, XOr));
-		}
-
-		static Parser<TToken, T> ChainOperatorRest<TToken, T, TOp>(
-			T firstOperand,
-			Parser<TToken, TOp> op,
-			Parser<TToken, T> operand,
-			Func<TOp, T, T, T> apply,
-			Func<Parser<TToken, T>, Parser<TToken, T>, Parser<TToken, T>> or)
-		{
-			if (op == null)
-				throw new ArgumentNullException(nameof(op));
-			if (operand == null)
-				throw new ArgumentNullException(nameof(operand));
-			if (apply == null)
-				throw new ArgumentNullException(nameof(apply));
-			return or(op.Then(opvalue =>
-						  operand.Then(operandValue =>
-							  ChainOperatorRest(apply(opvalue, firstOperand, operandValue), op, operand, apply, or))),
-					  Return<TToken, T>(firstOperand));
-		}
-
-		/// <summary>
-		/// Chain a right-associative operator.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <typeparam name="TOp"></typeparam>
-		/// <param name="op"></param>
-		/// <param name="operand"></param>
-		/// <param name="apply"></param>
-		/// <returns></returns>
-		public static Parser<TToken, T> ChainRightOperator<TToken, T, TOp>(
-			Parser<TToken, TOp> op,
-			Parser<TToken, T> operand,
-			Func<TOp, T, T, T> apply)
-		{
-			if (op == null)
-				throw new ArgumentNullException(nameof(op));
-			if (operand == null)
-				throw new ArgumentNullException(nameof(operand));
-			if (apply == null)
-				throw new ArgumentNullException(nameof(apply));
-			return operand.Then(first => ChainRightOperatorRest(first, op, operand, apply, Or));
-		}
-
-		/// <summary>
-		/// Chain a right-associative operator.
-		/// </summary>
-		/// <typeparam name="TToken"></typeparam>
-		/// <typeparam name="T"></typeparam>
-		/// <typeparam name="TOp"></typeparam>
-		/// <param name="op"></param>
-		/// <param name="operand"></param>
-		/// <param name="apply"></param>
-		/// <returns></returns>
-		public static Parser<TToken, T> XChainRightOperator<TToken, T, TOp>(
-			Parser<TToken, TOp> op,
-			Parser<TToken, T> operand,
-			Func<TOp, T, T, T> apply)
-		{
-			if (op == null)
-				throw new ArgumentNullException(nameof(op));
-			if (operand == null)
-				throw new ArgumentNullException(nameof(operand));
-			if (apply == null)
-				throw new ArgumentNullException(nameof(apply));
-			return operand.Then(first => ChainRightOperatorRest(first, op, operand, apply, XOr));
-		}
-
-		static Parser<TToken, T> ChainRightOperatorRest<TToken, T, TOp>(
-			T lastOperand,
-			Parser<TToken, TOp> op,
-			Parser<TToken, T> operand,
-			Func<TOp, T, T, T> apply,
-			Func<Parser<TToken, T>, Parser<TToken, T>, Parser<TToken, T>> or)
-		{
-			if (op == null)
-				throw new ArgumentNullException(nameof(op));
-			if (operand == null)
-				throw new ArgumentNullException(nameof(operand));
-			if (apply == null)
-				throw new ArgumentNullException(nameof(apply));
-			return or(op.Then(opvalue =>
-						operand.Then(operandValue =>
-							ChainRightOperatorRest(operandValue, op, operand, apply, or)).Then(r =>
-								Return<TToken, T>(apply(opvalue, lastOperand, r)))),
-					  Return<TToken, T>(lastOperand));
-		}
-
-
-		#region sequence
-		public static Parser<TToken, IEnumerable<T>> DelimitedBy<TToken, T, U>(
-			this Parser<TToken, T> parser,
-			Parser<TToken, U> delimiter
-			)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-			if (delimiter == null)
-				throw new ArgumentNullException(nameof(delimiter));
-
-			return
-				from head in parser.Once()
-				from tail in
-					(
-						from seprattor in delimiter
-						from item in parser
-						select item
-					).Many()
-				select head.Concat(tail);
-		}
-
-		public static Parser<TToken, IEnumerable<T>> XDelimitedBy<TToken, T, U>(
-			this Parser<TToken, T> itemParser,
-			Parser<TToken, U> delimiter
-			)
-		{
-			if (itemParser == null)
-				throw new ArgumentNullException(nameof(itemParser));
-
-			if (delimiter == null)
-				throw new ArgumentNullException(nameof(delimiter));
-
-			return
-				from head in itemParser.Once()
-				from tail in
-					(
-						from seprator in delimiter
-						from item in itemParser
-						select item
-					).XMany()
-				select head.Concat(tail);
-		}
-
-		public static Parser<TToken, IEnumerable<T>> Repeat<TToken, T>(
-			this Parser<TToken, T> parser,
-			int count
-			)
-			=> Repeat<TToken, T>(parser, count, count);
-
-		public static Parser<TToken, IEnumerable<T>> Repeat<TToken, T>(
-			this Parser<TToken, T> parser,
-			int minimumCount,
-			int maximumCount
-			)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-
-			return i =>
-				{
-					var remainder = i;
-					var result = new List<T>();
-
-					for (var n = 0; n < maximumCount; ++n)
-					{
-						var r = parser(remainder);
-
-						if (!r.IsSuccess && n < minimumCount)
-						{
-							var what = r.Rest.AtEnd
-								? "end of input"
-								: r.Rest.GetCurrent().ToString();
-
-							var msg = $"Unexpected '{what}'";
-							var exp = minimumCount == maximumCount
-								? $"'{string.Join(", ", r.Expected)}' {minimumCount} times, but found {n}"
-								: $"'{string.Join(", ", r.Expected)}' between {minimumCount} and {maximumCount} times, but found {n}";
-
-							return ParserResult<TToken, IEnumerable<T>>.Failure(i, new[] { exp }, msg);
-						}
-
-						if (!ReferenceEquals(remainder, r.Rest))
-						{
-							result.Add(r.Value);
-						}
-
-						remainder = r.Rest;
-					}
-
-					return ParserResult<TToken, IEnumerable<T>>.Success(remainder, result);
-				};
-		}
-
-		internal static Parser<char, T> TryConvert<T>(string str, Func<string, T> converter)
-		{
-			return i =>
-			{
-				try
-				{
-					return ParserResult<char, T>.Success(i, converter(str));
-				}
-				catch (FormatException)
-				{
-					return ParserResult<char, T>.Failure(i, $"Failed to parse {str}");
-				}
-			};
-		}
-
-		#endregion
-	}
-
-}
\ No newline at end of file
+using System.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+
+namespace NBitcoin.Scripting.Parser
+{
+	internal static partial class Parse
+	{
+
+
+		public static Parser<TToken, U> Then<TToken, T, U>(this Parser<TToken, T> first, Func<T, Parser<TToken, U>> second)
+		{
+			if (first == null)
+				throw new ArgumentNullException(nameof(first));
+			if (second == null)
+				throw new ArgumentNullException(nameof(second));
+
+			return i => first(i).IfSuccess(s => second(s.Value)(s.Rest));
+		}
+
+		public static Parser<TToken, IEnumerable<T>> Many<TToken, T>(this Parser<TToken, T> parser)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+
+			return i =>
+			{
+				var rest = i;
+				var result = new List<T>();
+				var r = parser(i);
+				while (r.IsSuccess)
+				{
+					if (rest.Equals(r.Rest))
+						break;
+					result.Add(r.Value);
+					rest = r.Rest;
+					r = parser(rest);
+				}
+
+				return ParserResult<TToken, IEnumerable<T>>.Success(rest, result);
+			};
+		}
+
+		/// <summary>
+		/// Parse a stream of elements, failing if any element is only partially parsed.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T">The type of element to parse.</typeparam>
+		/// <param name="parser">A parser that matches a single element.</param>
+		/// <returns>A <see cref="Parser{T}"/> that matches the sequence.</returns>
+		/// <remarks>
+		/// <para>
+		/// Using <seealso cref="XMany{TToken, T}(Parser{TToken, T})"/> may be preferable to <seealso cref="Many{TToken, T}(Parser{TToken, T})"/>
+		/// where the first character of each match identified by <paramref name="parser"/>
+		/// is sufficient to determine whether the entire match should succeed. The X*
+		/// methods typically give more helpful errors and are easier to debug than their
+		/// unqualified counterparts.
+		/// </para>
+		/// </remarks>
+		/// <seealso cref="XOr"/>
+		public static Parser<TToken, IEnumerable<T>> XMany<TToken, T>(this Parser<TToken, T> parser)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+
+			return parser.Many<TToken, T>().Then(m => parser.Once().XOr(Return<TToken, IEnumerable<T>>(m)));
+		}
+
+		/// <summary>
+		/// TryParse a stream of elements with at least one item.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="parser"></param>
+		/// <returns></returns>
+		public static Parser<TToken, IEnumerable<T>> AtLeastOnce<TToken, T>(this Parser<TToken, T> parser)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+
+			return parser.Once().Then(t1 => parser.Many().Select(ts => t1.Concat(ts)));
+		}
+
+		public static Parser<TToken, IEnumerable<T>> Once<TToken, T>(this Parser<TToken, T> parser)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+			return parser.Select(r => (IEnumerable<T>)new[] { r });
+		}
+
+		public static Parser<TToken, IEnumerable<T>> AtLeastOne<TToken, T>(this Parser<TToken, T> parser)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+
+			return parser.Once().Then(t1 => parser.Many().Select(ts => t1.Concat(ts)));
+		}
+
+		/// <summary>
+		/// TryParse a stream of elements with at least one item. Except the first
+		/// item, all other items will be matched with the <code>XMany</code> operator.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="parser"></param>
+		/// <returns></returns>
+		public static Parser<TToken, IEnumerable<T>> XAtLeastOnce<TToken, T>(this Parser<TToken, T> parser)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+
+			return parser.Once().Then(t1 => parser.XMany().Select(ts => t1.Concat(ts)));
+		}
+
+		/// <summary>
+		/// Lift to a parser monad world
+		/// </summary>
+		/// <param name="v"></param>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <returns></returns>
+		public static Parser<TToken, T> Return<TToken, T>(T v)
+			=> i => ParserResult<TToken, T>.Success(i, v);
+
+		/// <summary>
+		/// Take the result of parsing, and project it onto a different domain.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="U"></typeparam>
+		/// <param name="parser"></param>
+		/// <param name="convert"></param>
+		/// <returns></returns>
+		public static Parser<TToken, U> Select<TToken, T, U>(this Parser<TToken, T> parser, Func<T, U> convert)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+			if (convert == null)
+				throw new ArgumentNullException(nameof(convert));
+
+			return parser.Then(t => Return<TToken, U>(convert(t)));
+		}
+
+		public static Parser<TToken, IEnumerable<T>> Sequence<TToken, T>(this IEnumerable<Parser<TToken, T>> parserList)
+		{
+			return
+				parserList
+					.Aggregate(Return<TToken, IEnumerable<T>>(Enumerable.Empty<T>()), (a, p) => a.Concat(p.Once()));
+		}
+
+		/// <summary>
+		/// Refer to another parser indirectly. This allows circular compile-time dependency between parsers.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="reference"></param>
+		/// <returns></returns>
+		public static Parser<TToken, T> Ref<TToken, T>(Func<Parser<TToken, T>> reference)
+		{
+			if (reference == null)
+				throw new ArgumentNullException(nameof(reference));
+
+			Parser<TToken, T> p = null;
+
+			return i =>
+				{
+					if (p == null)
+						p = reference();
+
+					if (i.Memos.ContainsKey(p))
+						throw new ParsingException(i.Memos[p].ToString());
+
+					i.Memos[p] = ParserResult<TToken, T>.Failure(i,
+						new string[0],
+						"Left recursion in the grammar."
+					);
+					var result = p(i);
+					i.Memos[p] = result;
+					return result;
+				};
+		}
+
+
+		public static Parser<TToken, T> Or<TToken, T>(this Parser<TToken, T> first, Parser<TToken, T> second)
+		{
+			if (first == null)
+				throw new ArgumentNullException(nameof(first));
+			if (second == null)
+				throw new ArgumentNullException(nameof(second));
+
+			return i =>
+			{
+				var fr = first(i);
+				if (!fr.IsSuccess)
+					return second(i).IfFailure<T>(sf => DetermineBestError(fr, sf));
+
+				if (fr.Rest.Equals(i))
+					return second(i).IfFailure<T>(sf => fr);
+
+				return fr;
+			};
+		}
+
+
+		/// <summary>
+		/// Parse first, if it succeeds, return first, otherwise try second.
+		/// Assumes that the first parsed character will determine the parser chosen (see Try).
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="first"></param>
+		/// <param name="second"></param>
+		/// <returns></returns>
+		public static Parser<TToken, T> XOr<TToken, T>(this Parser<TToken, T> first, Parser<TToken, T> second)
+		{
+			if (first == null)
+				throw new ArgumentNullException(nameof(first));
+			if (second == null)
+				throw new ArgumentNullException(nameof(second));
+
+			return i =>
+			{
+				var fr = first(i);
+				if (!fr.IsSuccess)
+				{
+					// The 'X' part
+					if (!fr.Rest.Equals(i))
+						return fr;
+
+					return second(i).IfFailure<T>(sf => DetermineBestError(fr, sf));
+				}
+
+				// This handles a zero-length successful application of first.
+				if (fr.Rest.Equals(i))
+					return second(i).IfFailure<T>(sf => fr);
+
+				return fr;
+			};
+		}
+
+		/// <summary>
+		/// Concatenate two streams of elements.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="first"></param>
+		/// <param name="second"></param>
+		/// <returns></returns>
+		public static Parser<TToken, IEnumerable<T>> Concat<TToken, T>(this Parser<TToken, IEnumerable<T>> first, Parser<TToken, IEnumerable<T>> second)
+		{
+			if (first == null)
+				throw new ArgumentNullException(nameof(first));
+			if (second == null)
+				throw new ArgumentNullException(nameof(second));
+
+			return first.Then(f => second.Select(f.Concat));
+		}
+
+		public static ParserResult<TToken, T> DetermineBestError<TToken, T>(
+			ParserResult<TToken, T> firstF,
+			ParserResult<TToken, T> secondF
+			)
+		{
+			if (secondF.Rest.Position > firstF.Rest.Position)
+				return secondF;
+
+			if (secondF.Rest.Position == firstF.Rest.Position)
+				return ParserResult<TToken, T>.Failure(
+					firstF.Rest,
+					firstF.Expected.Union(secondF.Expected),
+					firstF.Description
+				);
+
+			return firstF;
+		}
+
+
+		/// <summary>
+		/// Version of Return with simpler inline syntax.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="U"></typeparam>
+		/// <param name="parser"></param>
+		/// <param name="value"></param>
+		/// <returns></returns>
+		public static Parser<TToken, U> Return<TToken, T, U>(this Parser<TToken, T> parser, U value)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+			return parser.Select(t => value);
+		}
+
+
+		/// <summary>
+		/// Attempt parsing only if the <paramref name="except"/> parser fails.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="U"></typeparam>
+		/// <param name="parser"></param>
+		/// <param name="except"></param>
+		/// <returns></returns>
+		public static Parser<TToken, T> Except<TToken, T, U>(this Parser<TToken, T> parser, Parser<TToken, U> except)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+			if (except == null)
+				throw new ArgumentNullException(nameof(except));
+
+			// Could be more like: except.Then(s => s.Fail("..")).XOr(parser)
+			return i =>
+				{
+					var r = except(i);
+					if (r.IsSuccess)
+						return ParserResult<TToken, T>.Failure(i, new[] { "other than the excepted input" }, "Excepted parser succeeded.");
+					return parser(i);
+				};
+		}
+
+		public static Parser<TToken, T> End<TToken, T>(this Parser<TToken, T> parser)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+
+			return i => parser(i).IfSuccess(s =>
+				s.Rest.AtEnd ? s : ParserResult<TToken, T>.Failure(
+					s.Rest,
+					new[] { "end of input" },
+					string.Format("unexpected '{0}'", s.Rest.GetCurrent())
+				)
+			);
+		}
+		/// <summary>
+		/// Parse a sequence of items until a terminator is reached.
+		/// Returns the sequence, discarding the terminator.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="U"></typeparam>
+		/// <param name="parser"></param>
+		/// <param name="until"></param>
+		/// <returns></returns>
+		public static Parser<TToken, IEnumerable<T>> Until<TToken, T, U>(this Parser<TToken, T> parser, Parser<TToken, U> until)
+		{
+			return parser.Except(until).Many().Then(r => until.Return(r));
+		}
+
+
+		/// <summary>
+		/// Succeed if the parsed value matches predicate.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="parser"></param>
+		/// <param name="predicate"></param>
+		/// <returns></returns>
+		public static Parser<TToken, T> Where<TToken, T>(this Parser<TToken, T> parser, Func<T, bool> predicate)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+			if (predicate == null)
+				throw new ArgumentNullException(nameof(predicate));
+
+			return i => parser(i).IfSuccess(s =>
+				predicate(s.Value) ? s : ParserResult<TToken, T>.Failure(i,
+					new string[0],
+					string.Format("Unexpected {0}.", s.Value)
+					)
+				);
+		}
+
+
+		/// <summary>
+		/// Monadic combinator Then, adapted for Linq comprehension syntax.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="U"></typeparam>
+		/// <typeparam name="V"></typeparam>
+		/// <param name="parser"></param>
+		/// <param name="selector"></param>
+		/// <param name="projector"></param>
+		/// <returns></returns>
+		public static Parser<TToken, V> SelectMany<TToken, T, U, V>(
+			this Parser<TToken, T> parser,
+			Func<T, Parser<TToken, U>> selector,
+			Func<T, U, V> projector)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+			if (selector == null)
+				throw new ArgumentNullException(nameof(selector));
+			if (projector == null)
+				throw new ArgumentNullException(nameof(projector));
+
+			return parser.Then(t => selector(t).Select(u => projector(t, u)));
+		}
+
+		public static Parser<TToken, U> Bind<TToken, T, U>(
+			this Parser<TToken, T> parser,
+			Func<T, Parser<TToken, U>> selector
+		)
+			=> parser.SelectMany(selector, (t, u) => u);
+
+		/// <summary>
+		/// Chain a left-associative operator.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="TOp"></typeparam>
+		/// <param name="op"></param>
+		/// <param name="operand"></param>
+		/// <param name="apply"></param>
+		/// <returns></returns>
+		public static Parser<TToken, T> ChainOperator<TToken, T, TOp>(
+			Parser<TToken, TOp> op,
+			Parser<TToken, T> operand,
+			Func<TOp, T, T, T> apply)
+		{
+			if (op == null)
+				throw new ArgumentNullException(nameof(op));
+			if (operand == null)
+				throw new ArgumentNullException(nameof(operand));
+			if (apply == null)
+				throw new ArgumentNullException(nameof(apply));
+			return operand.Then(first => ChainOperatorRest(first, op, operand, apply, Or));
+		}
+
+		/// <summary>
+		/// Chain a left-associative operator.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="TOp"></typeparam>
+		/// <param name="op"></param>
+		/// <param name="operand"></param>
+		/// <param name="apply"></param>
+		/// <returns></returns>
+		public static Parser<TToken, T> XChainOperator<TToken, T, TOp>(
+			Parser<TToken, TOp> op,
+			Parser<TToken, T> operand,
+			Func<TOp, T, T, T> apply)
+		{
+			if (op == null)
+				throw new ArgumentNullException(nameof(op));
+			if (operand == null)
+				throw new ArgumentNullException(nameof(operand));
+			if (apply == null)
+				throw new ArgumentNullException(nameof(apply));
+			return operand.Then(first => ChainOperatorRest(first, op, operand, apply, XOr));
+		}
+
+		static Parser<TToken, T> ChainOperatorRest<TToken, T, TOp>(
+			T firstOperand,
+			Parser<TToken, TOp> op,
+			Parser<TToken, T> operand,
+			Func<TOp, T, T, T> apply,
+			Func<Parser<TToken, T>, Parser<TToken, T>, Parser<TToken, T>> or)
+		{
+			if (op == null)
+				throw new ArgumentNullException(nameof(op));
+			if (operand == null)
+				throw new ArgumentNullException(nameof(operand));
+			if (apply == null)
+				throw new ArgumentNullException(nameof(apply));
+			return or(op.Then(opvalue =>
+						  operand.Then(operandValue =>
+							  ChainOperatorRest(apply(opvalue, firstOperand, operandValue), op, operand, apply, or))),
+					  Return<TToken, T>(firstOperand));
+		}
+
+		/// <summary>
+		/// Chain a right-associative operator.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="TOp"></typeparam>
+		/// <param name="op"></param>
+		/// <param name="operand"></param>
+		/// <param name="apply"></param>
+		/// <returns></returns>
+		public static Parser<TToken, T> ChainRightOperator<TToken, T, TOp>(
+			Parser<TToken, TOp> op,
+			Parser<TToken, T> operand,
+			Func<TOp, T, T, T> apply)
+		{
+			if (op == null)
+				throw new ArgumentNullException(nameof(op));
+			if (operand == null)
+				throw new ArgumentNullException(nameof(operand));
+			if (apply == null)
+				throw new ArgumentNullException(nameof(apply));
+			return operand.Then(first => ChainRightOperatorRest(first, op, operand, apply, Or));
+		}
+
+		/// <summary>
+		/// Chain a right-associative operator.
+		/// </summary>
+		/// <typeparam name="TToken"></typeparam>
+		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="TOp"></typeparam>
+		/// <param name="op"></param>
+		/// <param name="operand"></param>
+		/// <param name="apply"></param>
+		/// <returns></returns>
+		public static Parser<TToken, T> XChainRightOperator<TToken, T, TOp>(
+			Parser<TToken, TOp> op,
+			Parser<TToken, T> operand,
+			Func<TOp, T, T, T> apply)
+		{
+			if (op == null)
+				throw new ArgumentNullException(nameof(op));
+			if (operand == null)
+				throw new ArgumentNullException(nameof(operand));
+			if (apply == null)
+				throw new ArgumentNullException(nameof(apply));
+			return operand.Then(first => ChainRightOperatorRest(first, op, operand, apply, XOr));
+		}
+
+		static Parser<TToken, T> ChainRightOperatorRest<TToken, T, TOp>(
+			T lastOperand,
+			Parser<TToken, TOp> op,
+			Parser<TToken, T> operand,
+			Func<TOp, T, T, T> apply,
+			Func<Parser<TToken, T>, Parser<TToken, T>, Parser<TToken, T>> or)
+		{
+			if (op == null)
+				throw new ArgumentNullException(nameof(op));
+			if (operand == null)
+				throw new ArgumentNullException(nameof(operand));
+			if (apply == null)
+				throw new ArgumentNullException(nameof(apply));
+			return or(op.Then(opvalue =>
+						operand.Then(operandValue =>
+							ChainRightOperatorRest(operandValue, op, operand, apply, or)).Then(r =>
+								Return<TToken, T>(apply(opvalue, lastOperand, r)))),
+					  Return<TToken, T>(lastOperand));
+		}
+
+
+		#region sequence
+		public static Parser<TToken, IEnumerable<T>> DelimitedBy<TToken, T, U>(
+			this Parser<TToken, T> parser,
+			Parser<TToken, U> delimiter
+			)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+			if (delimiter == null)
+				throw new ArgumentNullException(nameof(delimiter));
+
+			return
+				from head in parser.Once()
+				from tail in
+					(
+						from seprattor in delimiter
+						from item in parser
+						select item
+					).Many()
+				select head.Concat(tail);
+		}
+
+		public static Parser<TToken, IEnumerable<T>> XDelimitedBy<TToken, T, U>(
+			this Parser<TToken, T> itemParser,
+			Parser<TToken, U> delimiter
+			)
+		{
+			if (itemParser == null)
+				throw new ArgumentNullException(nameof(itemParser));
+
+			if (delimiter == null)
+				throw new ArgumentNullException(nameof(delimiter));
+
+			return
+				from head in itemParser.Once()
+				from tail in
+					(
+						from seprator in delimiter
+						from item in itemParser
+						select item
+					).XMany()
+				select head.Concat(tail);
+		}
+
+		public static Parser<TToken, IEnumerable<T>> Repeat<TToken, T>(
+			this Parser<TToken, T> parser,
+			int count
+			)
+			=> Repeat<TToken, T>(parser, count, count);
+
+		public static Parser<TToken, IEnumerable<T>> Repeat<TToken, T>(
+			this Parser<TToken, T> parser,
+			int minimumCount,
+			int maximumCount
+			)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+
+			return i =>
+				{
+					var remainder = i;
+					var result = new List<T>();
+
+					for (var n = 0; n < maximumCount; ++n)
+					{
+						var r = parser(remainder);
+
+						if (!r.IsSuccess && n < minimumCount)
+						{
+							var what = r.Rest.AtEnd
+								? "end of input"
+								: r.Rest.GetCurrent().ToString();
+
+							var msg = $"Unexpected '{what}'";
+							var exp = minimumCount == maximumCount
+								? $"'{string.Join(", ", r.Expected)}' {minimumCount} times, but found {n}"
+								: $"'{string.Join(", ", r.Expected)}' between {minimumCount} and {maximumCount} times, but found {n}";
+
+							return ParserResult<TToken, IEnumerable<T>>.Failure(i, new[] { exp }, msg);
+						}
+
+						if (!ReferenceEquals(remainder, r.Rest))
+						{
+							result.Add(r.Value);
+						}
+
+						remainder = r.Rest;
+					}
+
+					return ParserResult<TToken, IEnumerable<T>>.Success(remainder, result);
+				};
+		}
+
+		internal static Parser<char, T> TryConvert<T>(string str, Func<string, T> converter)
+		{
+			return i =>
+			{
+				try
+				{
+					return ParserResult<char, T>.Success(i, converter(str));
+				}
+				catch (FormatException)
+				{
+					return ParserResult<char, T>.Failure(i, $"Failed to parse {str}");
+				}
+			};
+		}
+
+		#endregion
+	}
+
+}
diff --git a/NBitcoin/Scripting/Parser/Parser.cs b/NBitcoin/Scripting/Parser/Parser.cs
index 6c294760de..f63d359372 100644
--- a/NBitcoin/Scripting/Parser/Parser.cs
+++ b/NBitcoin/Scripting/Parser/Parser.cs
@@ -1,85 +1,86 @@
-using System;
-using System.Collections.Generic;
-
-namespace NBitcoin.Scripting.Parser
-{
-	internal delegate ParserResult<TToken, TValue> Parser<TToken, TValue>(IInput<TToken> input);
-
-	internal delegate ParserResult<char, TValue> Parser<TValue>(IInput<char> input);
-	internal static class ParserExtension
-	{
-		/// <summary>
-		/// Tries to parse the input without throwing an exception.
-		/// </summary>
-		/// <typeparam name="T">The type of the result.</typeparam>
-		/// <param name="parser">The parser.</param>
-		/// <param name="input">The input.</param>
-		/// <returns>The result of the parser</returns>
-		internal static ParserResult<char, T> TryParse<T>(this Parser<char, T> parser, string input)
-		{
-			if (parser == null)
-				throw new System.ArgumentNullException(nameof(parser));
-
-			if (input == null)
-				throw new System.ArgumentNullException(nameof(input));
-
-			return parser(new StringInput(input));
-		}
-
-		/// <summary>
-		/// Parses the specified input string.
-		/// </summary>
-		/// <typeparam name="T">The type of the result.</typeparam>
-		/// <param name="parser">The parser.</param>
-		/// <param name="input">The input.</param>
-		/// <returns>The result of the parser.</returns>
-		/// <exception cref="ParsingException">It contains the details of the parsing error.</exception>
-		internal static T Parse<T>(this Parser<char, T> parser, string input)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-			if (input == null)
-				throw new ArgumentNullException(nameof(input));
-
-			var result = parser.TryParse(input);
-
-			if (!result.IsSuccess)
-				throw new ParsingException(result.ToString(), result.Rest.Position);
-			return result.Value;
-		}
-
-		internal static ParserResult<ScriptToken, T> TryParse<T>(this Parser<ScriptToken, T> parser, Script input)
-		{
-			if (parser == null)
-				throw new System.ArgumentNullException(nameof(parser));
-
-			if (input == null)
-				throw new System.ArgumentNullException(nameof(input));
-
-			try
-			{
-				return parser(new ScriptInput(input));
-			}
-			// Catching exception here is bit ugly, but converting `Script` to `ScriptToken` is itself unsafe
-			// so this is good for assuring purity of this method.
-			catch (ParsingException e)
-			{
-				return ParserResult<ScriptToken, T>.Failure(new ScriptInput(new ScriptToken[] { }), e.Message);
-			}
-		}
-
-		internal static T Parse<T>(this Parser<ScriptToken, T> parser, Script input)
-		{
-			if (parser == null)
-				throw new ArgumentNullException(nameof(parser));
-			if (input == null)
-				throw new ArgumentNullException(nameof(input));
-
-			var result = parser.TryParse(input);
-
-			if (!result.IsSuccess)
-				throw new ParsingException(result.ToString(), result.Rest.Position);
-			return result.Value;
-		}
-	}
-}
\ No newline at end of file
+using System;
+using System.Collections.Generic;
+using NBitcoin.Scripting.Miniscript;
+
+namespace NBitcoin.Scripting.Parser
+{
+	internal delegate ParserResult<TToken, TValue> Parser<TToken, TValue>(IInput<TToken> input);
+
+	internal delegate ParserResult<char, TValue> Parser<TValue>(IInput<char> input);
+	internal static class ParserExtension
+	{
+		/// <summary>
+		/// Tries to parse the input without throwing an exception.
+		/// </summary>
+		/// <typeparam name="T">The type of the result.</typeparam>
+		/// <param name="parser">The parser.</param>
+		/// <param name="input">The input.</param>
+		/// <returns>The result of the parser</returns>
+		internal static ParserResult<char, T> TryParse<T>(this Parser<char, T> parser, string input)
+		{
+			if (parser == null)
+				throw new System.ArgumentNullException(nameof(parser));
+
+			if (input == null)
+				throw new System.ArgumentNullException(nameof(input));
+
+			return parser(new StringInput(input));
+		}
+
+		/// <summary>
+		/// Parses the specified input string.
+		/// </summary>
+		/// <typeparam name="T">The type of the result.</typeparam>
+		/// <param name="parser">The parser.</param>
+		/// <param name="input">The input.</param>
+		/// <returns>The result of the parser.</returns>
+		/// <exception cref="ParsingException">It contains the details of the parsing error.</exception>
+		internal static T Parse<T>(this Parser<char, T> parser, string input)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+			if (input == null)
+				throw new ArgumentNullException(nameof(input));
+
+			var result = parser.TryParse(input);
+
+			if (!result.IsSuccess)
+				throw new ParsingException(result.ToString(), result.Rest.Position);
+			return result.Value;
+		}
+
+		internal static ParserResult<ScriptToken, T> TryParse<T>(this Parser<ScriptToken, T> parser, Script input)
+		{
+			if (parser == null)
+				throw new System.ArgumentNullException(nameof(parser));
+
+			if (input == null)
+				throw new System.ArgumentNullException(nameof(input));
+
+			try
+			{
+				return parser(new ScriptInput(input));
+			}
+			// Catching exception here is bit ugly, but converting `Script` to `ScriptToken` is itself unsafe
+			// so this is good for assuring purity of this method.
+			catch (ParsingException e)
+			{
+				return ParserResult<ScriptToken, T>.Failure(new ScriptInput(new ScriptToken[] { }), e.Message);
+			}
+		}
+
+		internal static T Parse<T>(this Parser<ScriptToken, T> parser, Script input)
+		{
+			if (parser == null)
+				throw new ArgumentNullException(nameof(parser));
+			if (input == null)
+				throw new ArgumentNullException(nameof(input));
+
+			var result = parser.TryParse(input);
+
+			if (!result.IsSuccess)
+				throw new ParsingException(result.ToString(), result.Rest.Position);
+			return result.Value;
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Parser/ScriptInput.cs b/NBitcoin/Scripting/Parser/ScriptInput.cs
index 547d20fe89..4a8aa0fe60 100644
--- a/NBitcoin/Scripting/Parser/ScriptInput.cs
+++ b/NBitcoin/Scripting/Parser/ScriptInput.cs
@@ -1,47 +1,48 @@
-using System.Collections.Generic;
-using System;
-using System.Collections;
-
-namespace NBitcoin.Scripting.Parser
-{
-	internal class ScriptInput : IInput<ScriptToken>
-	{
-		public ScriptInput(Script source) : this(source.ToTokens(), 0) { }
-
-		public ScriptInput(ScriptToken[] source) : this(source, 0) { }
-
-		public ScriptToken[] Source { get; }
-		public int Position { get; }
-
-		internal ScriptInput(ScriptToken[] source, int position)
-		{
-			if (source == null)
-				throw new System.ArgumentNullException(nameof(source));
-			Source = source;
-			Position = position;
-			Memos = new Dictionary<object, object>();
-		}
-
-		public bool AtEnd { get { return Position == Source.Length; } }
-		public ScriptToken GetCurrent() => Source[Position];
-
-		public IInput<ScriptToken> Advance()
-		{
-			if (AtEnd)
-				throw new InvalidOperationException("The input is already at the end of the source");
-			return new ScriptInput(Source, Position + 1);
-		}
-
-		public IEnumerator<ScriptToken> GetEnumerator()
-		{
-			return ((IEnumerable<ScriptToken>)Source).GetEnumerator();
-		}
-
-		IEnumerator IEnumerable.GetEnumerator()
-		{
-			return this.Source.GetEnumerator();
-		}
-
-		public IDictionary<object, object> Memos { get; }
-	}
-}
\ No newline at end of file
+using System.Collections.Generic;
+using System;
+using System.Collections;
+using NBitcoin.Scripting.Miniscript;
+
+namespace NBitcoin.Scripting.Parser
+{
+	internal class ScriptInput : IInput<ScriptToken>
+	{
+		public ScriptInput(Script source) : this(ScriptToken.FromScript(source), 0) { }
+
+		public ScriptInput(ScriptToken[] source) : this(source, 0) { }
+
+		public ScriptToken[] Source { get; }
+		public int Position { get; }
+
+		internal ScriptInput(ScriptToken[] source, int position)
+		{
+			if (source == null)
+				throw new System.ArgumentNullException(nameof(source));
+			Source = source;
+			Position = position;
+			Memos = new Dictionary<object, object>();
+		}
+
+		public bool AtEnd { get { return Position == Source.Length; } }
+		public ScriptToken GetCurrent() => Source[Position];
+
+		public IInput<ScriptToken> Advance()
+		{
+			if (AtEnd)
+				throw new InvalidOperationException("The input is already at the end of the source");
+			return new ScriptInput(Source, Position + 1);
+		}
+
+		public IEnumerator<ScriptToken> GetEnumerator()
+		{
+			return ((IEnumerable<ScriptToken>)Source).GetEnumerator();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return this.Source.GetEnumerator();
+		}
+
+		public IDictionary<object, object> Memos { get; }
+	}
+}
diff --git a/NBitcoin/Scripting/ScriptExtensions.cs b/NBitcoin/Scripting/ScriptExtensions.cs
deleted file mode 100644
index 8aa5f48096..0000000000
--- a/NBitcoin/Scripting/ScriptExtensions.cs
+++ /dev/null
@@ -1,188 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using NBitcoin.Scripting.Parser;
-
-namespace NBitcoin.Scripting
-{
-	public static class ScriptExtensions
-	{
-		internal static ScriptToken[] ToTokens(this Script sc)
-		{
-			var result = new List<ScriptToken>();
-			foreach (Op op in sc.ToOps())
-			{
-				switch (op.Code)
-				{
-					case OpcodeType.OP_BOOLAND:
-						result.Add(ScriptToken.BoolAnd);
-						break;
-					case OpcodeType.OP_BOOLOR:
-						result.Add(ScriptToken.BoolOr);
-						break;
-					case OpcodeType.OP_EQUAL:
-						result.Add(ScriptToken.Equal);
-						break;
-					case OpcodeType.OP_EQUALVERIFY:
-						result.Add(ScriptToken.EqualVerify);
-						break;
-					case OpcodeType.OP_CHECKSIG:
-						result.Add(ScriptToken.CheckSig);
-						break;
-					case OpcodeType.OP_CHECKSIGVERIFY:
-						result.Add(ScriptToken.CheckSigVerify);
-						break;
-					case OpcodeType.OP_CHECKMULTISIG:
-						result.Add(ScriptToken.CheckMultiSig);
-						break;
-					case OpcodeType.OP_CHECKMULTISIGVERIFY:
-						result.Add(ScriptToken.CheckMultiSigVerify);
-						break;
-					case OpcodeType.OP_CHECKSEQUENCEVERIFY:
-						result.Add(ScriptToken.CheckSequenceVerify);
-						break;
-					case OpcodeType.OP_FROMALTSTACK:
-						result.Add(ScriptToken.FromAltStack);
-						break;
-					case OpcodeType.OP_TOALTSTACK:
-						result.Add(ScriptToken.ToAltStack);
-						break;
-					case OpcodeType.OP_DROP:
-						result.Add(ScriptToken.Drop);
-						break;
-					case OpcodeType.OP_DUP:
-						result.Add(ScriptToken.Dup);
-						break;
-					case OpcodeType.OP_IF:
-						result.Add(ScriptToken.If);
-						break;
-					case OpcodeType.OP_IFDUP:
-						result.Add(ScriptToken.IfDup);
-						break;
-					case OpcodeType.OP_NOTIF:
-						result.Add(ScriptToken.NotIf);
-						break;
-					case OpcodeType.OP_ELSE:
-						result.Add(ScriptToken.Else);
-						break;
-					case OpcodeType.OP_ENDIF:
-						result.Add(ScriptToken.EndIf);
-						break;
-					case OpcodeType.OP_0NOTEQUAL:
-						result.Add(ScriptToken.ZeroNotEqual);
-						break;
-					case OpcodeType.OP_SIZE:
-						result.Add(ScriptToken.Size);
-						break;
-					case OpcodeType.OP_SWAP:
-						result.Add(ScriptToken.Swap);
-						break;
-					case OpcodeType.OP_VERIFY:
-						result.Add(ScriptToken.Verify);
-						break;
-					case OpcodeType.OP_HASH160:
-						result.Add(ScriptToken.Hash160);
-						break;
-					case OpcodeType.OP_SHA256:
-						result.Add(ScriptToken.Sha256);
-						break;
-					case OpcodeType.OP_ADD:
-						result.Add(ScriptToken.Add);
-						break;
-					case OpcodeType.OP_0:
-						result.Add(new ScriptToken.Number(0u));
-						break;
-					case OpcodeType.OP_1:
-						result.Add(new ScriptToken.Number(1u));
-						break;
-					case OpcodeType.OP_2:
-						result.Add(new ScriptToken.Number(2u));
-						break;
-					case OpcodeType.OP_3:
-						result.Add(new ScriptToken.Number(3u));
-						break;
-					case OpcodeType.OP_4:
-						result.Add(new ScriptToken.Number(4u));
-						break;
-					case OpcodeType.OP_5:
-						result.Add(new ScriptToken.Number(5u));
-						break;
-					case OpcodeType.OP_6:
-						result.Add(new ScriptToken.Number(6u));
-						break;
-					case OpcodeType.OP_7:
-						result.Add(new ScriptToken.Number(7u));
-						break;
-					case OpcodeType.OP_8:
-						result.Add(new ScriptToken.Number(8u));
-						break;
-					case OpcodeType.OP_9:
-						result.Add(new ScriptToken.Number(9u));
-						break;
-					case OpcodeType.OP_10:
-						result.Add(new ScriptToken.Number(10u));
-						break;
-					case OpcodeType.OP_11:
-						result.Add(new ScriptToken.Number(11u));
-						break;
-					case OpcodeType.OP_12:
-						result.Add(new ScriptToken.Number(12u));
-						break;
-					case OpcodeType.OP_13:
-						result.Add(new ScriptToken.Number(13u));
-						break;
-					case OpcodeType.OP_14:
-						result.Add(new ScriptToken.Number(14u));
-						break;
-					case OpcodeType.OP_15:
-						result.Add(new ScriptToken.Number(15u));
-						break;
-					case OpcodeType.OP_16:
-						result.Add(new ScriptToken.Number(16u));
-						break;
-					default:
-						if ((byte)0x01 <= (byte)op.Code && (byte)op.Code < (byte)0x48)
-							result.Add(GetItem(op));
-						else if ((byte)0x48 <= (byte)op.Code)
-							throw new ParsingException($"Miniscript does not support pushdata bigger than 33. Got {op}");
-						else
-							throw new ParsingException($"Unknown Opcode to Miniscript {op.Name}");
-						break;
-				}
-			}
-			result.Reverse();
-			return result.ToArray();
-		}
-		private static ScriptToken GetItem(Op op)
-		{
-			if (op.PushData.Length == 20)
-			{
-				return new ScriptToken.Hash160Hash(new uint160(op.PushData, false));
-			}
-			if (op.PushData.Length == 32)
-			{
-				return new ScriptToken.Sha256Hash(new uint256(op.PushData, false));
-			}
-			if (op.PushData.Length == 33)
-			{
-				try
-				{
-					return new ScriptToken.Pk(new PubKey(op.PushData));
-				}
-				catch (FormatException ex)
-				{
-					throw new ParsingException("Invalid Public Key", ex);
-				}
-			}
-			var i = op.GetInt();
-			if (i.HasValue)
-			{
-				return new ScriptToken.Number((UInt32)i.Value);
-			}
-			else
-			{
-				throw new ParsingException($"Invalid push with Opcode {op}");
-			}
-		}
-	}
-}
\ No newline at end of file
diff --git a/NBitcoin/Scripting/ScriptToken.cs b/NBitcoin/Scripting/ScriptToken.cs
deleted file mode 100644
index a3b465869a..0000000000
--- a/NBitcoin/Scripting/ScriptToken.cs
+++ /dev/null
@@ -1,327 +0,0 @@
-using System;
-
-namespace NBitcoin.Scripting
-{
-	internal class ScriptToken : IEquatable<ScriptToken>
-	{
-		internal static class Tags
-		{
-			public const int BoolAnd = 0;
-
-			public const int BoolOr = 1;
-
-			public const int Add = 2;
-
-			public const int Equal = 3;
-
-			public const int EqualVerify = 4;
-
-			public const int CheckSig = 5;
-
-			public const int CheckSigVerify = 6;
-
-			public const int CheckMultiSig = 7;
-
-			public const int CheckMultiSigVerify = 8;
-
-			public const int CheckSequenceVerify = 9;
-
-			public const int FromAltStack = 10;
-
-			public const int ToAltStack = 11;
-
-			public const int Drop = 12;
-
-			public const int Dup = 13;
-
-			public const int If = 14;
-
-			public const int IfDup = 15;
-
-			public const int NotIf = 16;
-
-			public const int Else = 17;
-
-			public const int EndIf = 18;
-
-			public const int ZeroNotEqual = 19;
-
-			public const int Size = 20;
-
-			public const int Swap = 21;
-
-			public const int Verify = 23;
-
-			public const int Hash160 = 24;
-
-			public const int Sha256 = 25;
-
-			public const int Number = 26;
-
-			public const int Hash160Hash = 27;
-
-			public const int Sha256Hash = 28;
-
-			public const int Pk = 29;
-
-		}
-
-		private ScriptToken(int tag) => Tag = tag;
-
-		internal int Tag { get; }
-
-		internal static readonly ScriptToken _unique_BoolAnd = new ScriptToken(0);
-		internal static ScriptToken BoolAnd { get { return _unique_BoolAnd; } }
-		internal static readonly ScriptToken _unique_BoolOr = new ScriptToken(1);
-		internal static ScriptToken BoolOr { get { return _unique_BoolOr; } }
-
-		internal static readonly ScriptToken _unique_Add = new ScriptToken(2);
-		internal static ScriptToken Add { get { return _unique_Add; } }
-
-		internal static readonly ScriptToken _unique_Equal = new ScriptToken(3);
-		internal static ScriptToken Equal { get { return _unique_Equal; } }
-
-		internal static readonly ScriptToken _unique_EqualVerify = new ScriptToken(4);
-		internal static ScriptToken EqualVerify { get { return _unique_EqualVerify; } }
-
-		internal static readonly ScriptToken _unique_CheckSig = new ScriptToken(5);
-		internal static ScriptToken CheckSig { get { return _unique_CheckSig; } }
-
-		internal static readonly ScriptToken _unique_CheckSigVerify = new ScriptToken(6);
-		internal static ScriptToken CheckSigVerify { get { return _unique_CheckSigVerify; } }
-		internal static readonly ScriptToken _unique_CheckMultiSig = new ScriptToken(7);
-		internal static ScriptToken CheckMultiSig { get { return _unique_CheckMultiSig; } }
-		internal static readonly ScriptToken _unique_CheckMultiSigVerify = new ScriptToken(8);
-		internal static ScriptToken CheckMultiSigVerify { get { return _unique_CheckMultiSigVerify; } }
-
-		internal static readonly ScriptToken _unique_CheckSequenceVerify = new ScriptToken(9);
-		internal static ScriptToken CheckSequenceVerify { get { return _unique_CheckSequenceVerify; } }
-		internal static readonly ScriptToken _unique_FromAltStack = new ScriptToken(10);
-		internal static ScriptToken FromAltStack { get { return _unique_FromAltStack; } }
-		internal static readonly ScriptToken _unique_ToAltStack = new ScriptToken(11);
-		internal static ScriptToken ToAltStack { get { return _unique_ToAltStack; } }
-
-		internal static readonly ScriptToken _unique_Drop = new ScriptToken(12);
-		internal static ScriptToken Drop { get { return _unique_Drop; } }
-
-		internal static readonly ScriptToken _unique_Dup = new ScriptToken(13);
-		internal static ScriptToken Dup { get { return _unique_Dup; } }
-
-		internal static readonly ScriptToken _unique_If = new ScriptToken(14);
-		internal static ScriptToken If { get { return _unique_If; } }
-		internal static readonly ScriptToken _unique_IfDup = new ScriptToken(15);
-		internal static ScriptToken IfDup { get { return _unique_IfDup; } }
-
-		internal static readonly ScriptToken _unique_NotIf = new ScriptToken(16);
-		internal static ScriptToken NotIf { get { return _unique_NotIf; } }
-
-		internal static readonly ScriptToken _unique_Else = new ScriptToken(17);
-		internal static ScriptToken Else { get { return _unique_Else; } }
-
-		internal static readonly ScriptToken _unique_EndIf = new ScriptToken(18);
-		internal static ScriptToken EndIf { get { return _unique_EndIf; } }
-		internal static readonly ScriptToken _unique_ZeroNotEqual = new ScriptToken(19);
-		internal static ScriptToken ZeroNotEqual { get { return _unique_ZeroNotEqual; } }
-
-		internal static readonly ScriptToken _unique_Size = new ScriptToken(20);
-		internal static ScriptToken Size { get { return _unique_Size; } }
-
-		internal static readonly ScriptToken _unique_Swap = new ScriptToken(21);
-		internal static ScriptToken Swap { get { return _unique_Swap; } }
-		internal static readonly ScriptToken _unique_Verify = new ScriptToken(23);
-		internal static ScriptToken Verify { get { return _unique_Verify; } }
-		internal static readonly ScriptToken _unique_Hash160 = new ScriptToken(24);
-		internal static ScriptToken Hash160 { get { return _unique_Hash160; } }
-		internal static readonly ScriptToken _unique_Sha256 = new ScriptToken(25);
-		internal static ScriptToken Sha256 { get { return _unique_Sha256; } }
-		internal class Number : ScriptToken
-		{
-			internal uint Item { get; }
-			internal Number(uint item) : base(26) => Item = item;
-		}
-
-		internal class Hash160Hash : ScriptToken
-		{
-			internal uint160 Item { get; }
-			internal Hash160Hash(uint160 item) : base(27)
-			{
-				Item = item;
-			}
-		}
-		internal class Sha256Hash : ScriptToken
-		{
-			internal uint256 Item { get; }
-			internal Sha256Hash(uint256 item) : base(28) => Item = item;
-		}
-		internal class Pk : ScriptToken
-		{
-			internal PubKey Item { get; }
-			internal Pk(PubKey item) : base(29) => Item = item;
-		}
-
-		public override string ToString()
-		{
-			switch (this.Tag)
-			{
-				case Tags.BoolAnd:
-					return "BoolAnd";
-				case Tags.BoolOr:
-					return "BoolAnd";
-				case Tags.Add:
-					return "Add";
-				case Tags.Equal:
-					return "Equal";
-				case Tags.EqualVerify:
-					return "EqualVerify";
-				case Tags.CheckSig:
-					return "CheckSig";
-				case Tags.CheckSigVerify:
-					return "CheckSigVerify";
-				case Tags.CheckMultiSig:
-					return "CheckMultiSig";
-				case Tags.CheckMultiSigVerify:
-					return "CheckMultiSigVerify";
-				case Tags.CheckSequenceVerify:
-					return "CheckSequenceVerify";
-				case Tags.FromAltStack:
-					return "FromAltStack";
-				case Tags.ToAltStack:
-					return "ToAltStack";
-				case Tags.Drop:
-					return "Drop";
-				case Tags.Dup:
-					return "Dup";
-				case Tags.If:
-					return "If";
-				case Tags.IfDup:
-					return "IfDup";
-				case Tags.NotIf:
-					return "NotIf";
-				case Tags.Else:
-					return "Else";
-				case Tags.EndIf:
-					return "EndIf";
-				case Tags.ZeroNotEqual:
-					return "ZeroNotEqual";
-				case Tags.Size:
-					return "Size";
-				case Tags.Swap:
-					return "Swap";
-				case Tags.Verify:
-					return "Verify";
-				case Tags.Hash160:
-					return "Hash160";
-				case Tags.Sha256:
-					return "Sha256";
-				case Tags.Number:
-					var n = ((Number)this).Item;
-					return $"Number({n})";
-				case Tags.Hash160Hash:
-					var hash160 = ((Hash160Hash)this).Item;
-					return $"Hash160Hash({hash160})";
-				case Tags.Sha256Hash:
-					var sha256 = ((Sha256Hash)this).Item;
-					return $"Sha256Hash({sha256})";
-				case Tags.Pk:
-					var pk = ((Pk)this).Item;
-					return $"Pk({pk})";
-			}
-			throw new Exception("Unreachable");
-		}
-
-		public sealed override int GetHashCode()
-		{
-			if (this != null)
-			{
-				int num = 0;
-				switch (Tag)
-				{
-					case 26:
-						{
-							Number number = (Number)this;
-							num = 26;
-							return -1640531527 + ((int)number.Item + ((num << 6) + (num >> 2)));
-						}
-					case 27:
-						{
-							Hash160Hash hash160Hash = (Hash160Hash)this;
-							num = 27;
-							return -1640531527 + (hash160Hash.Item.GetHashCode()) + ((num << 6) + (num >> 2));
-						}
-					case 28:
-						{
-							Sha256Hash sha256Hash = (Sha256Hash)this;
-							num = 28;
-							return -1640531527 + (sha256Hash.Item.GetHashCode()) + ((num << 6) + (num >> 2));
-						}
-					case 29:
-						{
-							Pk pk = (Pk)this;
-							num = 29;
-							return -1640531527 + (pk.Item.GetHashCode()) + ((num << 6) + (num >> 2));
-						}
-					default:
-						return Tag;
-				}
-			}
-			return 0;
-		}
-
-		public sealed override bool Equals(object obj)
-		{
-			ScriptToken token = obj as ScriptToken;
-			if (token != null)
-			{
-				return Equals(token);
-			}
-			return false;
-		}
-		public bool Equals(ScriptToken obj)
-		{
-			if (this != null)
-			{
-				if (obj != null)
-				{
-					int tag = Tag;
-					int tag2 = obj.Tag;
-					if (tag == tag2)
-					{
-						switch (Tag)
-						{
-							case 26:
-								{
-									Number number = (Number)this;
-									Number number2 = (Number)obj;
-									return number.Item == number2.Item;
-								}
-							case 27:
-								{
-									Hash160Hash hash160Hash = (Hash160Hash)this;
-									Hash160Hash hash160Hash2 = (Hash160Hash)obj;
-									return hash160Hash.Item == hash160Hash2.Item;
-								}
-							case 28:
-								{
-									Sha256Hash sha256Hash = (Sha256Hash)this;
-									Sha256Hash sha256Hash2 = (Sha256Hash)obj;
-									return sha256Hash.Item == sha256Hash2.Item;
-								}
-							case 29:
-								{
-									Pk pk = (Pk)this;
-									Pk pk2 = (Pk)obj;
-									return pk.Item == pk2.Item;
-								}
-							default:
-								return true;
-						}
-					}
-					return false;
-				}
-				return false;
-			}
-			return obj == null;
-		}
-
-	}
-}
\ No newline at end of file
diff --git a/NBitcoin/UInt2561.cs b/NBitcoin/UInt2561.cs
index 2f1b4ef4b7..ab377bf7c0 100644
--- a/NBitcoin/UInt2561.cs
+++ b/NBitcoin/UInt2561.cs
@@ -2,6 +2,7 @@
 using System;
 using System.Linq;
 using NBitcoin.DataEncoders;
+using NBitcoin.Scripting.Miniscript;
 
 namespace NBitcoin
 {
@@ -493,7 +494,7 @@ public override int GetHashCode()
 			return hash;
 		}
 	}
-	public sealed class uint160 : IComparable<uint160>, IEquatable<uint160>, IComparable
+	public sealed class uint160 : IComparable<uint160>, IEquatable<uint160>, IComparable, IMiniscriptKeyHash
 	{
 		public class MutableUint160 : IBitcoinSerializable
 		{
@@ -851,5 +852,10 @@ public override int GetHashCode()
 			}
 			return hash;
 		}
+
+		public uint160 ToHash160() => this;
+
+		public string ToHex() => ToString();
+
 	}
 }
diff --git a/NBitcoin/Utils.cs b/NBitcoin/Utils.cs
index fe8fa1aa81..827e02f045 100644
--- a/NBitcoin/Utils.cs
+++ b/NBitcoin/Utils.cs
@@ -324,7 +324,7 @@ public static IEnumerable<List<T>> Partition<T>(this IEnumerable<T> source, Func
 			if(offset > buffer.Length - count) throw new ArgumentOutOfRangeException("count");
 
 			//IO interruption not supported on these platforms.
-			
+
 			int totalReadCount = 0;
 #if !NOSOCKET
 			var interruptable = stream is NetworkStream && cancellation.CanBeCanceled;
@@ -417,6 +417,45 @@ public static int UnixTimestamp(this DateTime ignored)
 		}
 	}
 
+	internal static class ScriptExtensions
+	{
+		/// <summary>
+		/// Adds an `OP_VERIFY` to the script, unless the most-recently-added opcode has an
+		/// alternate `VERIFY` form, in which case that opcode
+		/// is replaced. e.g. `OP_CHECKSIG` will become `OP_CHECKSIGVERIFY`
+		/// </summary>
+		/// <param name="self"></param>
+		internal static List<Op> PushVerify(this List<Op> self)
+		{
+			if (self.Count == 0)
+			{
+				self.Add(OpcodeType.OP_VERIFY);
+				return self;
+			}
+
+			var last = (self.Last());
+			switch (last.Code)
+			{
+				case OpcodeType.OP_EQUAL:
+					self[self.Count - 1] = OpcodeType.OP_EQUALVERIFY;
+					break;
+				case OpcodeType.OP_NUMEQUAL:
+					self[self.Count - 1] = OpcodeType.OP_NUMEQUALVERIFY;
+					break;
+				case OpcodeType.OP_CHECKSIG:
+					self[self.Count - 1] = OpcodeType.OP_CHECKSIGVERIFY;
+					break;
+				case OpcodeType.OP_CHECKMULTISIG:
+					self[self.Count - 1] = OpcodeType.OP_CHECKMULTISIGVERIFY;
+					break;
+				default:
+					self.Add(OpcodeType.OP_VERIFY);
+					break;
+			}
+			return self;
+		}
+	}
+
 	internal static class ByteArrayExtensions
 	{
 		internal static bool StartWith(this byte[] data, byte[] versionBytes)