From 9adf2b009ccb4fcadfee5530d1f242d530563eff Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Fri, 18 Oct 2019 01:38:31 +0900
Subject: [PATCH 01/50] WIP: prepare miniscript

---
 NBitcoin.Tests/Generators/PSBTGenerator.cs    | 218 +++++-----
 NBitcoin/Scripting/Miniscript/AstElem.cs      | 133 ++++++
 NBitcoin/Scripting/Miniscript/Miniscript.cs   | 128 ++++++
 .../Scripting/Miniscript/MiniscriptKey.cs     |   7 +
 .../Miniscript/MiniscriptScriptParser.cs      | 391 ++++++++++++++++++
 .../Scripting/Miniscript/Policy/Compiler.cs   |  74 ++++
 NBitcoin/Scripting/Miniscript/Property.cs     |   7 +
 NBitcoin/Scripting/Miniscript/ScriptParser.cs |   7 +
 NBitcoin/Scripting/Miniscript/ScriptToken.cs  | 210 ++++++++++
 NBitcoin/Scripting/Miniscript/Tree.cs         |  13 +
 .../Scripting/Miniscript/Types/ExtData.cs     |  34 ++
 .../Miniscript/Types/Malleability.cs          |  51 +++
 NBitcoin/Scripting/Miniscript/Types/Types.cs  |   7 +
 13 files changed, 1171 insertions(+), 109 deletions(-)
 create mode 100644 NBitcoin/Scripting/Miniscript/AstElem.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Miniscript.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Property.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/ScriptParser.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/ScriptToken.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Tree.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Types/ExtData.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Types/Malleability.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Types/Types.cs

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/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
new file mode 100644
index 0000000000..20553779e9
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -0,0 +1,133 @@
+using System;
+using System.Linq.Expressions;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	internal class NonTerm : IEquatable<NonTerm>
+	{
+		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;
+		}
+
+		public bool Equals(NonTerm other)
+		{
+			throw new NotImplementedException("");
+		}
+	}
+
+	public class Terminal : IEquatable<Terminal>
+	{
+		internal static class Tags
+		{
+			public const int True = 0;
+			public const int False = 1;
+			public const int Pk = 2;
+			public const int PkH = 3;
+			public const int After = 4;
+			public const int Older = 5;
+			public const int Sha256 = 6;
+			public const int Hash256 = 7;
+			public const int Ripemd160 = 8;
+			public const int Hash160 = 9;
+			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 { get; }
+
+		private Terminal(int tag) => Tag = tag;
+		public static Terminal True { get; } = new Terminal(Tags.True);
+		public static Terminal False { get; } = new Terminal(Tags.False);
+
+		internal class Pk : Terminal
+		{
+			public PubKey Item;
+			public Pk(PubKey pk) : base(Tags.Pk) => Item = pk;
+		}
+
+		internal class PkH : Terminal
+		{
+			public uint160 Item;
+			public PkH(uint160 item) : base(Tags.PkH) => Item = item;
+		}
+
+		internal class After : Terminal
+		{
+			public uint Item;
+			public After(uint item) : base(Tags.After) => Item = item;
+		}
+
+		internal class Older : Terminal
+		{
+			public uint Item;
+			public Older(uint item) : base(Tags.Older) => Item = item;
+		}
+
+		internal class Sha256 : Terminal
+		{
+			public uint256 Item;
+			public Sha256(uint256 item) : base(Tags.Sha256) => Item = item;
+		}
+		internal class Hash256 : Terminal
+		{
+			public uint256 Item;
+			public Hash256(uint256 item) : base(Tags.Hash256) => Item = item;
+		}
+
+		internal class Ripemd160 : Terminal
+		{
+			public uint160 Item;
+			public Ripemd160(uint160 item) : base(Tags.Ripemd160) => Item = item;
+		}
+
+		internal class Hash160 : Terminal
+		{
+			public uint160 Item;
+			public Hash160(uint160 item) : base(Tags.Hash160) => Item = item;
+		}
+
+		public bool Equals(Terminal other)
+		{
+			throw new NotImplementedException();
+		}
+	}
+
+}
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
new file mode 100644
index 0000000000..3817c3ee27
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -0,0 +1,128 @@
+
+using System;
+using NBitcoin.Scripting.Miniscript.Types;
+
+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
+	}
+
+	public enum Input
+	{
+		Zero,
+		One,
+		Any,
+		OneNoneZero,
+		AnyNonZero
+	}
+
+	public static partial class InputExtensions
+	{
+		public static bool IsSubtype(this Input self, Input other)
+		{
+			if (self == other)
+				return true;
+
+			if (self == Input.OneNoneZero && other == Input.One)
+				return true;
+
+			if (self == Input.OneNoneZero && other == Input.AnyNonZero)
+				return true;
+
+			if (other == Input.Any)
+				return true;
+
+			return false;
+		}
+	}
+
+	public class Correctness
+	{
+		public Base Base;
+		public Input Input;
+		public bool DisSatisfiable;
+		/// <summary>
+		/// Whether the fragment's "nonzero' output on satisfaction is
+		/// always the constant 1.
+		/// </summary>
+		public bool Unit;
+
+		public bool IsSubtype(Correctness other) =>
+			(this.Base == other.Base) &&
+			(this.Input.IsSubtype(other.Input)) &&
+			(!(!(this.DisSatisfiable) && other.DisSatisfiable)) &&
+			(!(!(this.Unit) && other.Unit));
+	}
+
+	public class MiniscriptFragmentType
+	{
+		public Correctness Correctness;
+
+		internal Malleability Malleability;
+
+		public bool IsSubtype(MiniscriptFragmentType other) =>
+			this.Correctness.IsSubtype(other.Correctness) &&
+			this.Malleability.IsSubtype(other.Malleability);
+
+		public MiniscriptFragmentType TypeCheck(Terminal fragment, Func<UInt64, MiniscriptFragmentType> child)
+		{
+			throw new Exception(("TODO"));
+		}
+
+	}
+
+	public class Miniscript
+	{
+		internal readonly Terminal Node;
+		public readonly MiniscriptFragmentType Type;
+
+		/// <summary>
+		/// Additional information helpful for extra analysis.
+		/// </summary>
+		/// <returns></returns>
+		internal readonly ExtData Ext;
+
+		private Miniscript(MiniscriptFragmentType type, Terminal node, ExtData ext)
+		{
+			Type = type;
+			Node = node;
+			Ext = ext;
+		}
+
+		public static Miniscript FromAst(Terminal t) =>
+			new Miniscript(
+				MiniscriptFragmentType.TypeCheck(t, (_) => null),
+				t,
+				ExtData.TypeCheck(t, (_) => null)
+			);
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
new file mode 100644
index 0000000000..3c67c92b94
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
@@ -0,0 +1,7 @@
+namespace NBitcoin.Scripting.Miniscript
+{
+	public class MiniscriptKey
+	{
+		
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs b/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
new file mode 100644
index 0000000000..5a038bb670
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
@@ -0,0 +1,391 @@
+using System;
+using System.Linq;
+using NBitcoin.Scripting.Parser;
+
+using P = NBitcoin.Scripting.Parser.Parser<NBitcoin.Scripting.Miniscript.ScriptToken, NBitcoin.Scripting.Miniscript.AstElem>;
+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);
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
new file mode 100644
index 0000000000..fc7acbfb8e
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -0,0 +1,74 @@
+using System;
+
+namespace NBitcoin.Scripting.Miniscript.Policy
+{
+	public class CompilerException : Exception
+	{}
+
+	internal class 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) =>
+			this.Type.IsSubtype(other.Type);
+
+		private CompilationKey(MiniscriptFragmentType type, double? dissatProb, bool expensiveVerify)
+		{
+			Type = type;
+			DissatProb = dissatProb;
+			ExpensiveVerify = expensiveVerify;
+		}
+
+	}
+
+	internal class 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 double SatisfyCost;
+		internal double? DissatCost;
+	}
+
+	internal class AstElemExt
+	{
+		internal Miniscript Ms;
+		internal CompilerExtData CompilerExtData;
+
+		internal double CostLd(double satProb, double? dissatProb)
+		{
+			return this.Ms
+		}
+	}
+
+	public class Compiler
+	{
+
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Property.cs b/NBitcoin/Scripting/Miniscript/Property.cs
new file mode 100644
index 0000000000..8e8e92e6f4
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Property.cs
@@ -0,0 +1,7 @@
+namespace NBitcoin.Scripting.Miniscript
+{
+	public interface Property
+	{
+		
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/ScriptParser.cs b/NBitcoin/Scripting/Miniscript/ScriptParser.cs
new file mode 100644
index 0000000000..c37706de15
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/ScriptParser.cs
@@ -0,0 +1,7 @@
+namespace NBitcoin.Scripting.Miniscript
+{
+	internal static class ScriptParser
+	{
+
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/ScriptToken.cs b/NBitcoin/Scripting/Miniscript/ScriptToken.cs
new file mode 100644
index 0000000000..c8657060eb
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/ScriptToken.cs
@@ -0,0 +1,210 @@
+using System;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	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 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)
+		{
+			ScriptToken token = obj as ScriptToken;
+			if (token != null)
+			{
+				return Equals(token);
+			}
+			return false;
+		}
+		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;
+		}
+
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Tree.cs b/NBitcoin/Scripting/Miniscript/Tree.cs
new file mode 100644
index 0000000000..a3d23f059d
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Tree.cs
@@ -0,0 +1,13 @@
+namespace NBitcoin.Scripting.Miniscript
+{
+	public class Tree<T>
+	{
+		public string Name;
+		public Tree<T>[] Args;
+
+		public static Tree<T> Parse(string str)
+		{
+			throw new System.Exception("");
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/ExtData.cs b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
new file mode 100644
index 0000000000..b6cd0ee040
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
@@ -0,0 +1,34 @@
+using System;
+
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+	/// <summary>
+	///  Whether a fragment is OK to be used in non-segwit scripts
+	/// </summary>
+	internal enum LegacySafe
+	{
+		LegacySafe,
+		SegwitOnly
+	}
+	internal class ExtData
+	{
+		internal LegacySafe LegacySafe;
+		internal UInt64 PkCost;
+		internal bool HasVerifyForm;
+		internal UInt64 OpsCountStatic;
+		internal UInt64?  OpsCountSat;
+		internal UInt64? OpsCountNSat;
+
+		/// <summary>
+		///  Compute the type of a fragment, given a function to lookup
+		/// the types of its children, if available and relevant for the given fragment.
+		/// </summary>
+		/// <param name="fragment"></param>
+		/// <param name="child"></param>
+		/// <returns></returns>
+		internal static ExtData TypeCheck(Terminal fragment, Func<UInt64, ExtData> child)
+		{
+			throw new System.Exception("TODO");
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
new file mode 100644
index 0000000000..f7b37a4a3c
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -0,0 +1,51 @@
+using System.Runtime.InteropServices;
+
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+	internal class Malleability : Property
+	{
+		internal Dissat Dissat;
+		internal bool Safe;
+		internal bool NonMalleable;
+
+		private Malleability(Dissat dissat, bool safe, bool nonMalleable)
+		{
+			Dissat = dissat;
+			Safe = safe;
+			NonMalleable = nonMalleable;
+		}
+
+		internal bool IsSubtype(Malleability other) =>
+			this.Dissat.IsSubtype((other.Dissat)) &&
+			(!(!(this.Safe) && other.Safe)) &&
+			(!(!(this.NonMalleable) && other.NonMalleable));
+
+		internal static Malleability FromTrue() =>
+			new Malleability(Dissat.Unique, false, true);
+
+		internal static Malleability FromFalse() =>
+			new Malleability(Dissat.Unique,true, true);
+		internal static Malleability FromPk() =>
+			new Malleability(Dissat.Unique,true, true);
+	}
+
+	/// <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
+	{
+		None,
+		Unique,
+		Unknown
+	}
+
+	internal static class DissatExtension
+	{
+		internal static bool IsSubtype(this Dissat self, Dissat other) =>
+			(self == other) || other == Dissat.Unknown;
+
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/Types.cs b/NBitcoin/Scripting/Miniscript/Types/Types.cs
new file mode 100644
index 0000000000..7d7260ef32
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/Types.cs
@@ -0,0 +1,7 @@
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+	internal interface Property
+	{
+		void SanityChecks();
+	}
+}

From 14829ff4e05210d690254980ce53b073ccfe887f Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sat, 19 Oct 2019 00:21:54 +0900
Subject: [PATCH 02/50] Update

---
 .../Scripting/Descriptor/CreateDescriptor.cs  |   7 +
 NBitcoin/Scripting/Miniscript/AstElem.cs      | 362 +++++++++++++++++-
 .../Miniscript/MiniscriptScriptParser.cs      |   9 +-
 NBitcoin/Scripting/Miniscript/ScriptToken.cs  |  74 ++++
 NBitcoin/Scripting/Miniscript/Tree.cs         |   8 +-
 NBitcoin/Utils.cs                             |  41 +-
 6 files changed, 488 insertions(+), 13 deletions(-)
 create mode 100644 NBitcoin/Scripting/Descriptor/CreateDescriptor.cs

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/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 20553779e9..fab5fde994 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -1,5 +1,11 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
 using System.Linq.Expressions;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using System.Linq;
 
 namespace NBitcoin.Scripting.Miniscript
 {
@@ -33,6 +39,51 @@ internal static class Tags
 			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;
+			}
+		}
+
 		public bool Equals(NonTerm other)
 		{
 			throw new NotImplementedException("");
@@ -71,7 +122,7 @@ internal static class Tags
 			public const int ThreshM = 25;
 		}
 
-		internal int Tag { get; }
+		private int Tag;
 
 		private Terminal(int tag) => Tag = tag;
 		public static Terminal True { get; } = new Terminal(Tags.True);
@@ -79,55 +130,348 @@ internal static class Tags
 
 		internal class Pk : Terminal
 		{
-			public PubKey Item;
+			readonly public PubKey Item;
 			public Pk(PubKey pk) : base(Tags.Pk) => Item = pk;
 		}
 
 		internal class PkH : Terminal
 		{
-			public uint160 Item;
+			readonly public uint160 Item;
 			public PkH(uint160 item) : base(Tags.PkH) => Item = item;
 		}
 
 		internal class After : Terminal
 		{
-			public uint Item;
+			readonly public uint Item;
 			public After(uint item) : base(Tags.After) => Item = item;
 		}
 
 		internal class Older : Terminal
 		{
-			public uint Item;
+			readonly public uint Item;
 			public Older(uint item) : base(Tags.Older) => Item = item;
 		}
 
 		internal class Sha256 : Terminal
 		{
-			public uint256 Item;
+			readonly public uint256 Item;
 			public Sha256(uint256 item) : base(Tags.Sha256) => Item = item;
 		}
 		internal class Hash256 : Terminal
 		{
-			public uint256 Item;
+			readonly public uint256 Item;
 			public Hash256(uint256 item) : base(Tags.Hash256) => Item = item;
 		}
 
 		internal class Ripemd160 : Terminal
 		{
-			public uint160 Item;
+			readonly public uint160 Item;
 			public Ripemd160(uint160 item) : base(Tags.Ripemd160) => Item = item;
 		}
 
 		internal class Hash160 : Terminal
 		{
-			public uint160 Item;
+			readonly public uint160 Item;
 			public Hash160(uint160 item) : base(Tags.Hash160) => Item = item;
 		}
 
+		internal class Alt : Terminal
+		{
+			readonly public Miniscript Item;
+			public Alt(Miniscript item) : base(Tags.Alt) => Item = item;
+		}
+
+		internal class Swap : Terminal
+		{
+			readonly public Miniscript Item;
+			public Swap(Miniscript item): base(Tags.Swap) => Item = item;
+		}
+
+		internal class Check : Terminal
+		{
+			readonly public Miniscript Item;
+			public Check(Miniscript item): base(Tags.Check) => Item = item;
+		}
+		internal class DupIf : Terminal
+		{
+			readonly public Miniscript Item;
+			public DupIf (Miniscript item): base(Tags.DupIf ) => Item = item;
+		}
+		internal class Verify : Terminal
+		{
+			readonly public Miniscript Item;
+			public Verify(Miniscript item): base(Tags.Verify) => Item = item;
+		}
+		internal class NonZero : Terminal
+		{
+			readonly public Miniscript Item;
+			public NonZero(Miniscript item): base(Tags.NonZero) => Item = item;
+		}
+		internal class ZeroNotEqual : Terminal
+		{
+			readonly public Miniscript Item;
+			public ZeroNotEqual(Miniscript item): base(Tags.ZeroNotEqual) => Item = item;
+		}
+		internal class AndV : Terminal
+		{
+			readonly public Miniscript Item1;
+			readonly public Miniscript Item2;
+			public AndV(Miniscript item1,Miniscript item2): base(Tags.AndV)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+		internal class AndB : Terminal
+		{
+			readonly public Miniscript Item1;
+			readonly public Miniscript Item2;
+			public AndB(Miniscript item, Miniscript item2): base(Tags.AndB)
+			{
+				Item1 = item;
+				Item2 = item2;
+			}
+		}
+		internal class AndOr : Terminal
+		{
+			readonly public Miniscript Item1;
+			readonly public Miniscript Item2;
+			readonly public Miniscript Item3;
+
+			public AndOr(Miniscript item1, Miniscript item2, Miniscript item3) : base(Tags.AndOr)
+			{
+				Item1 = item1;
+				Item2 = item2;
+				Item3 = item3;
+			}
+		}
+		internal class OrB : Terminal
+		{
+			readonly public Miniscript Item1;
+			readonly public Miniscript Item2;
+			public OrB(Miniscript item1, Miniscript item2): base(Tags.OrB)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+		internal class OrD : Terminal
+		{
+			readonly public Miniscript Item1;
+			readonly public Miniscript Item2;
+			public OrD(Miniscript item1, Miniscript item2): base(Tags.OrD)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+
+		internal class OrC : Terminal
+		{
+			readonly public Miniscript Item1;
+			readonly public Miniscript Item2;
+			public OrC(Miniscript item1, Miniscript item2): base(Tags.OrC)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+
+		internal class OrI : Terminal
+		{
+			readonly public Miniscript Item1;
+			readonly public Miniscript Item2;
+			public OrI(Miniscript item1, Miniscript item2): base(Tags.OrI)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+		internal class Thresh : Terminal
+		{
+			readonly public ulong Item1;
+			readonly public Miniscript[] Item2;
+			public Thresh(ulong item1, Miniscript[] item2): base(Tags.Thresh)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+		internal class ThreshM : Terminal
+		{
+			readonly public ulong Item1;
+			readonly public Pk[] Item2;
+			public ThreshM(ulong item1, Pk[] item2): base(Tags.ThreshM)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
 		public bool Equals(Terminal other)
 		{
 			throw new NotImplementedException();
 		}
+
+		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.ToBytes()));
+					return l;
+				case PkH self:
+					l.Add(OpcodeType.OP_DUP);
+					l.Add(OpcodeType.OP_HASH160);
+					l.Add(Op.GetPushOp(self.Item.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(20));
+					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(20));
+					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 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.Item.ToBytes()));
+					}
+					l.Add(Op.GetPushOp(self.Item2.Length));
+					l.Add(OpcodeType.OP_CHECKMULTISIG);
+					return l;
+			}
+			throw new Exception(("Unreachable!"));
+		}
+
+		public ulong ScriptSize()
+		{}
 	}
 
 }
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs b/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
index 5a038bb670..f665ab5a29 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
@@ -2,11 +2,13 @@
 using System.Linq;
 using NBitcoin.Scripting.Parser;
 
-using P = NBitcoin.Scripting.Parser.Parser<NBitcoin.Scripting.Miniscript.ScriptToken, NBitcoin.Scripting.Miniscript.AstElem>;
+using P = NBitcoin.Scripting.Parser.Parser<NBitcoin.Scripting.Miniscript.ScriptToken, NBitcoin.Scripting.Miniscript.Miniscript>;
+
 namespace NBitcoin.Scripting.Miniscript
 {
 	internal static class MiniscriptScriptParser
 	{
+		/*
 
 		private static readonly Parser<ScriptToken, uint> PNumber =
 			from t in Parse.ScriptToken(ScriptToken.Tags.Number)
@@ -387,5 +389,10 @@ private static P PostProcess(AstElem ast)
 
 		public static AstElem ParseScript(Script sc)
 			=> PT.Parse(sc);
+		*/
+
+		private static readonly P
+
+		public static Terminal ParseScript(Script sc) =>
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/ScriptToken.cs b/NBitcoin/Scripting/Miniscript/ScriptToken.cs
index c8657060eb..45f781633b 100644
--- a/NBitcoin/Scripting/Miniscript/ScriptToken.cs
+++ b/NBitcoin/Scripting/Miniscript/ScriptToken.cs
@@ -206,5 +206,79 @@ public bool Equals(ScriptToken obj)
 			return false;
 		}
 
+		public static ScriptToken FromScript()
+		{
+			throw new Exception("");
+		}
+		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
index a3d23f059d..638559b4db 100644
--- a/NBitcoin/Scripting/Miniscript/Tree.cs
+++ b/NBitcoin/Scripting/Miniscript/Tree.cs
@@ -1,9 +1,13 @@
 namespace NBitcoin.Scripting.Miniscript
 {
+	/// <summary>
+	/// A token of the from `x()` or `x`
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
 	public class Tree<T>
 	{
-		public string Name;
-		public Tree<T>[] Args;
+		public readonly string Name;
+		public readonly Tree<T>[] Args;
 
 		public static Tree<T> Parse(string str)
 		{
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)

From d3956997889a737f641ee16f6307b0c727afe70d Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Tue, 29 Oct 2019 13:23:09 +0900
Subject: [PATCH 03/50] Update

---
 NBitcoin.Tests/MiniscriptTests.cs             |  189 +++
 NBitcoin.Tests/TransactionBuilderTests.cs     |   40 +
 NBitcoin/KeyId.cs                             |    6 +-
 NBitcoin/PubKey.cs                            |   33 +-
 .../Scripting/Descriptor/DescriptorError.cs   |    7 +
 NBitcoin/Scripting/Miniscript/AstElem.cs      |  690 +++++++--
 NBitcoin/Scripting/Miniscript/Base.cs         |   34 +
 NBitcoin/Scripting/Miniscript/ILiftable.cs    |   73 +
 NBitcoin/Scripting/Miniscript/Input.cs        |   11 +
 .../Scripting/Miniscript/InputExtensions.cs   |   22 +
 NBitcoin/Scripting/Miniscript/Miniscript.cs   |  133 +-
 .../MiniscriptDSLParser.Terminal.cs           |    7 +
 .../MiniscriptDSLParsers.ConcretePolicy.cs    |  216 +++
 .../Scripting/Miniscript/MiniscriptError.cs   |  276 ++++
 .../Scripting/Miniscript/MiniscriptKey.cs     |   34 +-
 .../Miniscript/MiniscriptScriptParser.cs      |   70 +-
 .../Miniscript/Policy/AbstractPolicy.cs       |  328 +++++
 .../Scripting/Miniscript/Policy/Compiler.cs   |  146 +-
 .../Miniscript/Policy/ConcretePolicy.cs       |  491 ++++++
 .../Miniscript/Policy/PolicyException.cs      |   23 +
 NBitcoin/Scripting/Miniscript/Property.cs     |    4 -
 NBitcoin/Scripting/Miniscript/Tree.cs         |   28 +-
 .../Scripting/Miniscript/Types/Correctness.cs |  188 +++
 .../Scripting/Miniscript/Types/ExtData.cs     |  173 ++-
 .../Scripting/Miniscript/Types/IProperty.cs   |  306 ++++
 .../Miniscript/Types/Malleability.cs          |  230 ++-
 .../Types/MiniscriptFragmentType.cs           |  284 ++++
 NBitcoin/Scripting/Miniscript/Types/Types.cs  |    4 -
 NBitcoin/Scripting/Parser/Parse.cs            | 1310 ++++++++---------
 29 files changed, 4441 insertions(+), 915 deletions(-)
 create mode 100644 NBitcoin.Tests/MiniscriptTests.cs
 create mode 100644 NBitcoin.Tests/TransactionBuilderTests.cs
 create mode 100644 NBitcoin/Scripting/Descriptor/DescriptorError.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Base.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/ILiftable.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Input.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/InputExtensions.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/MiniscriptError.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Policy/PolicyException.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Types/Correctness.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Types/IProperty.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
new file mode 100644
index 0000000000..64a5204254
--- /dev/null
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -0,0 +1,189 @@
+using System;
+using NBitcoin.Scripting.Miniscript;
+using NBitcoin.Scripting.Parser;
+using Xunit;
+
+namespace NBitcoin.Tests
+{
+	public static class MiniscriptTests
+	{
+		public static readonly 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]
+		[MemberData(nameof(MSAttributeTestCase))]
+		[Trait("Core", "Core")]
+		public static void MiniscriptAttributesTest(
+			string msStr, string expectedHex, bool valid, bool nonMalleable,
+			bool needSig, uint ops)
+		{
+			if (valid)
+			{
+				var ms = Miniscript<PubKey>.Parse(msStr);
+				Assert.Equal(ms.Encode().ToHex(), expectedHex);
+				Assert.Equal(ms.Type.Malleability.NonMalleable, nonMalleable);
+				Assert.Equal(ms.Type.Malleability.Safe, needSig);
+				Assert.Equal(ms.Ext.OpsCountSat, ops);
+			}
+			else
+			{
+				Assert.Throws<ParsingException>(() => Miniscript<PubKey>.Parse(msStr));
+			}
+		}
+	}
+}
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..6556b87013 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
 {
@@ -85,7 +86,7 @@ public override string ToString()
 			return _Str;
 		}
 	}
-	public class KeyId : TxDestination
+	public class KeyId : TxDestination , IMiniscriptKeyHash
 	{
 		public KeyId()
 			: this(0)
@@ -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/PubKey.cs b/NBitcoin/PubKey.cs
index eff831705a..c6ce0dcd19 100644
--- a/NBitcoin/PubKey.cs
+++ b/NBitcoin/PubKey.cs
@@ -8,6 +8,8 @@
 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 +31,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
 	{
 		/// <summary>
 		/// Create a new Public key from string
@@ -48,11 +50,29 @@ public PubKey(byte[] bytes)
 		{
 		}
 
+		public bool TryParse(string hex)
+		{
+			if (hex == null) throw new ArgumentNullException(nameof(hex));
+			var v = Hex.Decode(hex);
+			if (!Check(v, true))
+				return false;
+			vch = v;
+			try
+			{
+				_ECKey = new ECKey(v, false);
+			}
+			catch (Exception ex)
+			{
+				throw new FormatException("Invalid public key", ex);
+			}
+			return true;
+		}
+
 		/// <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)
@@ -555,5 +575,14 @@ public BitcoinWitPubKeyAddress GetSegwitAddress(Network network)
 		}
 
 		#endregion
+
+		public IMiniscriptKeyHash MiniscriptKeyHash => Hash;
+		public PubKey ToPublicKey() => this;
+
+		public int SerializedLength() =>
+			this.ToBytes().Length;
+
+		public uint160 HashToHash160(KeyId keyId) =>
+			new uint160(keyId._DestBytes);
 	}
 }
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
index fab5fde994..1ee089b842 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -1,16 +1,14 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
-using System.Globalization;
-using System.Linq.Expressions;
-using System.Reflection.Emit;
-using System.Runtime.CompilerServices;
+using System.Diagnostics;
 using System.Linq;
 
 namespace NBitcoin.Scripting.Miniscript
 {
 	internal class NonTerm : IEquatable<NonTerm>
 	{
+		#region Subtype definitions
+
 		internal static class Tags
 		{
 			public const int Expression = 0;
@@ -83,15 +81,19 @@ public ThreshE(ulong k, ulong n) : base(Tags.ThreshW)
 				K = k;
 			}
 		}
+		#endregion
 
+		#region Equatable members
 		public bool Equals(NonTerm other)
 		{
 			throw new NotImplementedException("");
 		}
+		#endregion
 	}
 
-	public class Terminal : IEquatable<Terminal>
+	public partial class Terminal<TPk> : IEquatable<Terminal<TPk>> where TPk : IMiniscriptKey
 	{
+		# region Subtype definitions
 		internal static class Tags
 		{
 			public const int True = 0;
@@ -122,195 +124,315 @@ internal static class Tags
 			public const int ThreshM = 25;
 		}
 
-		private int Tag;
+		internal int Tag;
 
 		private Terminal(int tag) => Tag = tag;
-		public static Terminal True { get; } = new Terminal(Tags.True);
-		public static Terminal False { get; } = new Terminal(Tags.False);
+		public static Terminal<TPk> True { get; } = new Terminal<TPk>(Tags.True);
+		public static Terminal<TPk> False { get; } = new Terminal<TPk>(Tags.False);
 
-		internal class Pk : Terminal
+		internal class Pk : Terminal<TPk>
 		{
-			readonly public PubKey Item;
-			public Pk(PubKey pk) : base(Tags.Pk) => Item = pk;
+			readonly public TPk Item;
+			public Pk(TPk pk) : base(Tags.Pk) => Item = pk;
 		}
 
-		internal class PkH : Terminal
+		internal class PkH : Terminal<TPk>
 		{
-			readonly public uint160 Item;
-			public PkH(uint160 item) : base(Tags.PkH) => Item = item;
+			readonly public IMiniscriptKeyHash Item;
+			public PkH(IMiniscriptKeyHash item) : base(Tags.PkH) => Item = item;
 		}
 
-		internal class After : Terminal
+		internal class After : Terminal<TPk>
 		{
 			readonly public uint Item;
 			public After(uint item) : base(Tags.After) => Item = item;
 		}
 
-		internal class Older : Terminal
+		internal class Older : Terminal<TPk>
 		{
 			readonly public uint Item;
 			public Older(uint item) : base(Tags.Older) => Item = item;
 		}
 
-		internal class Sha256 : Terminal
+		internal class Sha256 : Terminal<TPk>
 		{
 			readonly public uint256 Item;
 			public Sha256(uint256 item) : base(Tags.Sha256) => Item = item;
 		}
-		internal class Hash256 : Terminal
+		internal class Hash256 : Terminal<TPk>
 		{
 			readonly public uint256 Item;
 			public Hash256(uint256 item) : base(Tags.Hash256) => Item = item;
 		}
 
-		internal class Ripemd160 : Terminal
+		internal class Ripemd160 : Terminal<TPk>
 		{
 			readonly public uint160 Item;
 			public Ripemd160(uint160 item) : base(Tags.Ripemd160) => Item = item;
 		}
 
-		internal class Hash160 : Terminal
+		internal class Hash160 : Terminal<TPk>
 		{
 			readonly public uint160 Item;
 			public Hash160(uint160 item) : base(Tags.Hash160) => Item = item;
 		}
 
-		internal class Alt : Terminal
+		internal class Alt : Terminal<TPk>
 		{
-			readonly public Miniscript Item;
-			public Alt(Miniscript item) : base(Tags.Alt) => Item = item;
+			readonly public Miniscript<TPk> Item;
+			public Alt(Miniscript<TPk> item) : base(Tags.Alt) => Item = item;
 		}
 
-		internal class Swap : Terminal
+		internal class Swap : Terminal<TPk>
 		{
-			readonly public Miniscript Item;
-			public Swap(Miniscript item): base(Tags.Swap) => Item = item;
+			readonly public Miniscript<TPk> Item;
+			public Swap(Miniscript<TPk> item): base(Tags.Swap) => Item = item;
 		}
 
-		internal class Check : Terminal
+		internal class Check : Terminal<TPk>
 		{
-			readonly public Miniscript Item;
-			public Check(Miniscript item): base(Tags.Check) => Item = item;
+			readonly public Miniscript<TPk> Item;
+			public Check(Miniscript<TPk> item): base(Tags.Check) => Item = item;
 		}
-		internal class DupIf : Terminal
+		internal class DupIf : Terminal<TPk>
 		{
-			readonly public Miniscript Item;
-			public DupIf (Miniscript item): base(Tags.DupIf ) => Item = item;
+			readonly public Miniscript<TPk> Item;
+			public DupIf (Miniscript<TPk> item): base(Tags.DupIf ) => Item = item;
 		}
-		internal class Verify : Terminal
+		internal class Verify : Terminal<TPk>
 		{
-			readonly public Miniscript Item;
-			public Verify(Miniscript item): base(Tags.Verify) => Item = item;
+			readonly public Miniscript<TPk> Item;
+			public Verify(Miniscript<TPk> item): base(Tags.Verify) => Item = item;
 		}
-		internal class NonZero : Terminal
+		internal class NonZero : Terminal<TPk>
 		{
-			readonly public Miniscript Item;
-			public NonZero(Miniscript item): base(Tags.NonZero) => Item = item;
+			readonly public Miniscript<TPk> Item;
+			public NonZero(Miniscript<TPk> item): base(Tags.NonZero) => Item = item;
 		}
-		internal class ZeroNotEqual : Terminal
+		internal class ZeroNotEqual : Terminal<TPk>
 		{
-			readonly public Miniscript Item;
-			public ZeroNotEqual(Miniscript item): base(Tags.ZeroNotEqual) => Item = item;
+			readonly public Miniscript<TPk> Item;
+			public ZeroNotEqual(Miniscript<TPk> item): base(Tags.ZeroNotEqual) => Item = item;
 		}
-		internal class AndV : Terminal
+		internal class AndV : Terminal<TPk>
 		{
-			readonly public Miniscript Item1;
-			readonly public Miniscript Item2;
-			public AndV(Miniscript item1,Miniscript item2): base(Tags.AndV)
+			readonly public Miniscript<TPk> Item1;
+			readonly public Miniscript<TPk> Item2;
+			public AndV(Miniscript<TPk> item1,Miniscript<TPk> item2): base(Tags.AndV)
 			{
 				Item1 = item1;
 				Item2 = item2;
 			}
 		}
-		internal class AndB : Terminal
+		internal class AndB : Terminal<TPk>
 		{
-			readonly public Miniscript Item1;
-			readonly public Miniscript Item2;
-			public AndB(Miniscript item, Miniscript item2): base(Tags.AndB)
+			readonly public Miniscript<TPk> Item1;
+			readonly public Miniscript<TPk> Item2;
+			public AndB(Miniscript<TPk> item, Miniscript<TPk> item2): base(Tags.AndB)
 			{
 				Item1 = item;
 				Item2 = item2;
 			}
 		}
-		internal class AndOr : Terminal
+		internal class AndOr : Terminal<TPk>
 		{
-			readonly public Miniscript Item1;
-			readonly public Miniscript Item2;
-			readonly public Miniscript Item3;
+			readonly public Miniscript<TPk> Item1;
+			readonly public Miniscript<TPk> Item2;
+			readonly public Miniscript<TPk> Item3;
 
-			public AndOr(Miniscript item1, Miniscript item2, Miniscript item3) : base(Tags.AndOr)
+			public AndOr(Miniscript<TPk> item1, Miniscript<TPk> item2, Miniscript<TPk> item3) : base(Tags.AndOr)
 			{
 				Item1 = item1;
 				Item2 = item2;
 				Item3 = item3;
 			}
 		}
-		internal class OrB : Terminal
+		internal class OrB : Terminal<TPk>
 		{
-			readonly public Miniscript Item1;
-			readonly public Miniscript Item2;
-			public OrB(Miniscript item1, Miniscript item2): base(Tags.OrB)
+			readonly public Miniscript<TPk> Item1;
+			readonly public Miniscript<TPk> Item2;
+			public OrB(Miniscript<TPk> item1, Miniscript<TPk> item2): base(Tags.OrB)
 			{
 				Item1 = item1;
 				Item2 = item2;
 			}
 		}
-		internal class OrD : Terminal
+		internal class OrD : Terminal<TPk>
 		{
-			readonly public Miniscript Item1;
-			readonly public Miniscript Item2;
-			public OrD(Miniscript item1, Miniscript item2): base(Tags.OrD)
+			readonly public Miniscript<TPk> Item1;
+			readonly public Miniscript<TPk> Item2;
+			public OrD(Miniscript<TPk> item1, Miniscript<TPk> item2): base(Tags.OrD)
 			{
 				Item1 = item1;
 				Item2 = item2;
 			}
 		}
 
-		internal class OrC : Terminal
+		internal class OrC : Terminal<TPk>
 		{
-			readonly public Miniscript Item1;
-			readonly public Miniscript Item2;
-			public OrC(Miniscript item1, Miniscript item2): base(Tags.OrC)
+			readonly public Miniscript<TPk> Item1;
+			readonly public Miniscript<TPk> Item2;
+			public OrC(Miniscript<TPk> item1, Miniscript<TPk> item2): base(Tags.OrC)
 			{
 				Item1 = item1;
 				Item2 = item2;
 			}
 		}
 
-		internal class OrI : Terminal
+		internal class OrI : Terminal<TPk>
 		{
-			readonly public Miniscript Item1;
-			readonly public Miniscript Item2;
-			public OrI(Miniscript item1, Miniscript item2): base(Tags.OrI)
+			readonly public Miniscript<TPk> Item1;
+			readonly public Miniscript<TPk> Item2;
+			public OrI(Miniscript<TPk> item1, Miniscript<TPk> item2): base(Tags.OrI)
 			{
 				Item1 = item1;
 				Item2 = item2;
 			}
 		}
-		internal class Thresh : Terminal
+		internal class Thresh : Terminal<TPk>
 		{
-			readonly public ulong Item1;
-			readonly public Miniscript[] Item2;
-			public Thresh(ulong item1, Miniscript[] item2): base(Tags.Thresh)
+			readonly public uint Item1;
+			readonly public Miniscript<TPk>[] Item2;
+			public Thresh(uint item1, Miniscript<TPk>[] item2): base(Tags.Thresh)
 			{
 				Item1 = item1;
 				Item2 = item2;
 			}
 		}
-		internal class ThreshM : Terminal
+		internal class ThreshM : Terminal<TPk>
 		{
-			readonly public ulong Item1;
-			readonly public Pk[] Item2;
-			public ThreshM(ulong item1, Pk[] item2): base(Tags.ThreshM)
+			readonly public uint Item1;
+			readonly public TPk[] Item2;
+			public ThreshM(uint item1, TPk[] item2): base(Tags.ThreshM)
 			{
 				Item1 = item1;
 				Item2 = item2;
 			}
 		}
-		public bool Equals(Terminal other)
+
+		public static Terminal<TPk> NewTrue() => Terminal<TPk>.True;
+		public static Terminal<TPk> NewFalse() => Terminal<TPk>.False;
+		public static Terminal<TPk> NewPk(TPk item) => new Pk(item);
+		public static Terminal<TPk> NewPkH(IMiniscriptKeyHash item) => new PkH(item);
+		public static Terminal<TPk> NewAfter(uint item) => new After(item);
+		public static Terminal<TPk> NewOlder(uint item) => new Older(item);
+		public static Terminal<TPk> NewSha256(uint256 item)
+			=>  new Sha256(item);
+		public static Terminal<TPk> NewHash256(uint256 item)
+			=> new Hash256(item);
+		public static Terminal<TPk> NewRipemd160(uint160 item)
+			=> new Ripemd160(item);
+		public static Terminal<TPk> NewHash160(uint160 item)
+			=> new Hash160(item);
+		public static Terminal<TPk> NewAlt(Miniscript<TPk> item) => new Terminal<TPk>.Alt(item);
+		public static Terminal<TPk> NewSwap(Miniscript<TPk> item) => new Terminal<TPk>.Swap(item);
+		public static Terminal<TPk> NewCheck(Miniscript<TPk> item) => new Terminal<TPk>.Check(item);
+		public static Terminal<TPk> NewDupIf(Miniscript<TPk> item) => new DupIf(item);
+		public static Terminal<TPk> NewVerify(Miniscript<TPk> item) => new Verify(item);
+		public static Terminal<TPk> NewNonZero(Miniscript<TPk> item) => new NonZero(item);
+
+		public static Terminal<TPk> NewAndV(Miniscript<TPk> item1, Miniscript<TPk> item2)
+			=> new AndV(item1, item2);
+
+		public static Terminal<TPk> NewAndB(Miniscript<TPk> item1, Miniscript<TPk> item2)
+			=> new AndB(item1, item2);
+
+		public static Terminal<TPk> NewAndOr(Miniscript<TPk> item1, Miniscript<TPk> item2, Miniscript<TPk> item3)
+			=> new AndOr(item1, item2, item3);
+
+		public static Terminal<TPk> NewOrB(Miniscript<TPk> item1, Miniscript<TPk> item2)
+			=> new OrB(item1, item2);
+
+		public static Terminal<TPk> NewOrD(Miniscript<TPk> item1, Miniscript<TPk> item2)
+			=> new OrD(item1, item2);
+		public static Terminal<TPk> NewOrC(Miniscript<TPk> item1, Miniscript<TPk> item2)
+			=> new OrC(item1, item2);
+		public static Terminal<TPk> NewOrI(Miniscript<TPk> item1, Miniscript<TPk> item2)
+			=> new OrI(item1, item2);
+
+		public static Terminal<TPk> NewThresh(uint item1, IEnumerable<Miniscript<TPk>> item2)
+			=> new Thresh(item1, item2.ToArray());
+		public static Terminal<TPk> NewThreshM(uint item1, IEnumerable<TPk> item2)
+			=> new ThreshM(item1, item2.ToArray());
+		#endregion
+
+		#region Equatable members
+		public bool Equals(Terminal<TPk> other)
 		{
-			throw new NotImplementedException();
+			if (other == null)
+				return false;
+			if (this.Tag != other.Tag)
+				return false;
+
+			switch (this.Tag)
+			{
+				case Tags.True: return true;
+				case Tags.False: return true;
+			}
+
+			switch (this)
+			{
+				case Pk self:
+					return self.Item.Equals(((Pk) other).Item);
+				case PkH self:
+					return self.Item.Equals(((PkH) 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 Alt self:
+					return self.Item.Equals(((Alt) other).Item);
+				case Swap self:
+					return self.Item.Equals(((Swap) other).Item);
+				case Check self:
+					return self.Item.Equals(((Check) other).Item);
+				case DupIf self:
+					return self.Item.Equals(((DupIf) other).Item);
+				case Verify self:
+					return self.Item.Equals(((Verify) other).Item);
+				case NonZero self:
+					return self.Item.Equals(((NonZero) other).Item);
+				case ZeroNotEqual self:
+					return self.Item.Equals(((ZeroNotEqual) other).Item);
+				case AndV self:
+					var andv = (AndV) other;
+					return self.Item1.Equals(andv.Item1) && self.Item2.Equals(andv.Item2);
+				case AndB self:
+					var andb = (AndB) other;
+					return self.Item1.Equals(andb.Item1) && self.Item2.Equals(andb.Item2);
+				case AndOr self:
+					var andOr = (AndOr) other;
+					return self.Item1.Equals(andOr.Item1) && self.Item2.Equals(andOr.Item2) && self.Item3.Equals(andOr.Item3);
+				case OrB self:
+					var orb = (OrB) other;
+					return self.Item1.Equals(orb.Item1) && self.Item2.Equals(orb.Item2);
+				case OrD self:
+					var ord = (OrD) other;
+					return self.Item1.Equals(ord.Item1) && self.Item2.Equals(ord.Item2);
+				case OrC self:
+					var orc = (OrC) other;
+					return self.Item1.Equals(orc.Item1) && self.Item2.Equals(orc.Item2);
+				case OrI self:
+					var ori = (OrI) other;
+					return self.Item1.Equals(ori.Item1) && self.Item2.Equals(ori.Item2);
+				case Thresh self:
+					var t = (Thresh) other;
+					return self.Item1.Equals(t.Item1) && self.Item2.SequenceEqual(t.Item2);
+				case ThreshM self:
+					var tm = (ThreshM) other;
+					return self.Item1.Equals(tm.Item1) && self.Item2.SequenceEqual(tm.Item2);
+			}
+			throw new Exception("Unreachable!");
 		}
+		#endregion
 
 		public Script ToScript() =>
 			new Script(this.ToOpList());
@@ -329,12 +451,12 @@ private List<Op> ToOpList()
 			switch (this)
 			{
 				case Pk self:
-					l.Add(Op.GetPushOp(self.Item.ToBytes()));
+					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.ToBytes()));
+					l.Add(Op.GetPushOp(self.Item.ToHash160().ToBytes()));
 					l.Add(OpcodeType.OP_EQUALVERIFY);
 					return l;
 				case After self:
@@ -461,7 +583,7 @@ private List<Op> ToOpList()
 					l.Add(Op.GetPushOp((long)self.Item1));
 					foreach (var sub in self.Item2)
 					{
-						l.Add(Op.GetPushOp(sub.Item.ToBytes()));
+						l.Add(Op.GetPushOp(sub.ToPublicKey().ToBytes()));
 					}
 					l.Add(Op.GetPushOp(self.Item2.Length));
 					l.Add(OpcodeType.OP_CHECKMULTISIG);
@@ -470,8 +592,404 @@ private List<Op> ToOpList()
 			throw new Exception(("Unreachable!"));
 		}
 
-		public ulong ScriptSize()
-		{}
+		private int ScriptNumSize(int n) => ScriptNumSize((ulong)n);
+		private int ScriptNumSize(ulong n)
+		{
+			if (n <= 0x10) // OP_n
+				return 1;
+			if (n < 0x10) // 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>
+		}
+		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 ScriptNumSize(self.Item) + 1;
+				case Older self:
+					return 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
+						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
+						ScriptNumSize(self.Item1) +
+						1 +
+						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!");
+		}
 	}
 
 }
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..94596115dd
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/ILiftable.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NBitcoin.Scripting.Miniscript.Policy;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	public interface ILiftable<TPk> where TPk : IMiniscriptKey
+	{
+		AbstractPolicy<TPk> Lift();
+	}
+
+	public partial class Miniscript<TPk> : ILiftable<TPk> where TPk : IMiniscriptKey
+	{
+		public AbstractPolicy<TPk> Lift() =>
+			this.Node.Lift();
+	}
+
+	public partial class Terminal<TPk> : ILiftable<TPk> where TPk : IMiniscriptKey
+	{
+		public AbstractPolicy<TPk> Lift()
+		{
+			switch (this.Tag)
+			{
+				case Tags.True: return AbstractPolicy<TPk>.Trivial;
+				case Tags.False: return AbstractPolicy<TPk>.UnSatisfiable;
+			}
+
+			switch (this)
+			{
+				case Pk self: return AbstractPolicy<TPk>.NewKeyHash(self.Item.MiniscriptKeyHash);
+				case PkH self: return AbstractPolicy<TPk>.NewKeyHash(self.Item);
+				case After self: return AbstractPolicy<TPk>.NewAfter(self.Item);
+				case Older self: return AbstractPolicy<TPk>.NewOlder(self.Item);
+				case Sha256 self: return AbstractPolicy<TPk>.NewSha256(self.Item);
+				case Hash256 self: return AbstractPolicy<TPk>.NewHash256(self.Item);
+				case Ripemd160 self: return AbstractPolicy<TPk>.NewRipemd160(self.Item);
+				case Hash160 self: return AbstractPolicy<TPk>.NewHash160(self.Item);
+				case Alt self: return self.Item.Node.Lift();
+				case Check self: return self.Item.Node.Lift();
+				case DupIf self: return self.Item.Node.Lift();
+				case Verify self: return self.Item.Node.Lift();
+				case NonZero self: return self.Item.Node.Lift();
+				case ZeroNotEqual self: return self.Item.Node.Lift();
+				case AndV self:
+					return AbstractPolicy<TPk>.NewAnd(new List<AbstractPolicy<TPk>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift()});
+				case AndB self:
+					return AbstractPolicy<TPk>.NewAnd(new List<AbstractPolicy<TPk>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift()});
+				case AndOr self:
+					var inner = AbstractPolicy<TPk>.NewAnd(new List<AbstractPolicy<TPk>>() {self.Item1.Node.Lift(), self.Item3.Node.Lift()});
+					return AbstractPolicy<TPk>.NewOr(new List<AbstractPolicy<TPk>>() {inner, self.Item2.Node.Lift()});
+				case OrB self:
+					return AbstractPolicy<TPk>.NewOr(new List<AbstractPolicy<TPk>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() });
+				case OrD self:
+					return AbstractPolicy<TPk>.NewOr(new List<AbstractPolicy<TPk>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() });
+				case OrC self:
+					return AbstractPolicy<TPk>.NewOr(new List<AbstractPolicy<TPk>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() });
+				case OrI self:
+					return AbstractPolicy<TPk>.NewOr(new List<AbstractPolicy<TPk>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() });
+				case Thresh self:
+					return AbstractPolicy<TPk>.NewThreshold(self.Item1, self.Item2.Select(sub => sub.Node.Lift()).ToList());
+				case ThreshM self:
+					return
+						AbstractPolicy<TPk>.NewThreshold(
+							self.Item1,
+							self.Item2.Select(sub => AbstractPolicy<TPk>.NewKeyHash(sub.Item.MiniscriptKeyHash)).ToList()
+						);
+			}
+
+			throw new Exception("Unreachable!");
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Input.cs b/NBitcoin/Scripting/Miniscript/Input.cs
new file mode 100644
index 0000000000..f9b72e4f2f
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Input.cs
@@ -0,0 +1,11 @@
+namespace NBitcoin.Scripting.Miniscript
+{
+	public enum Input
+	{
+		Zero,
+		One,
+		Any,
+		OneNoneZero,
+		AnyNonZero
+	}
+}
\ No newline at end of file
diff --git a/NBitcoin/Scripting/Miniscript/InputExtensions.cs b/NBitcoin/Scripting/Miniscript/InputExtensions.cs
new file mode 100644
index 0000000000..02f3a94fb3
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/InputExtensions.cs
@@ -0,0 +1,22 @@
+namespace NBitcoin.Scripting.Miniscript
+{
+	public static partial class InputExtensions
+	{
+		public static bool IsSubtype(this Input self, Input other)
+		{
+			if (self == other)
+				return true;
+
+			if (self == Input.OneNoneZero && other == Input.One)
+				return true;
+
+			if (self == Input.OneNoneZero && other == Input.AnyNonZero)
+				return true;
+
+			if (other == Input.Any)
+				return true;
+
+			return false;
+		}
+	}
+}
\ No newline at end of file
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index 3817c3ee27..0dd1853254 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -1,108 +1,11 @@
-
 using System;
 using NBitcoin.Scripting.Miniscript.Types;
 
 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
-	}
-
-	public enum Input
-	{
-		Zero,
-		One,
-		Any,
-		OneNoneZero,
-		AnyNonZero
-	}
-
-	public static partial class InputExtensions
-	{
-		public static bool IsSubtype(this Input self, Input other)
-		{
-			if (self == other)
-				return true;
-
-			if (self == Input.OneNoneZero && other == Input.One)
-				return true;
-
-			if (self == Input.OneNoneZero && other == Input.AnyNonZero)
-				return true;
-
-			if (other == Input.Any)
-				return true;
-
-			return false;
-		}
-	}
-
-	public class Correctness
-	{
-		public Base Base;
-		public Input Input;
-		public bool DisSatisfiable;
-		/// <summary>
-		/// Whether the fragment's "nonzero' output on satisfaction is
-		/// always the constant 1.
-		/// </summary>
-		public bool Unit;
-
-		public bool IsSubtype(Correctness other) =>
-			(this.Base == other.Base) &&
-			(this.Input.IsSubtype(other.Input)) &&
-			(!(!(this.DisSatisfiable) && other.DisSatisfiable)) &&
-			(!(!(this.Unit) && other.Unit));
-	}
-
-	public class MiniscriptFragmentType
+	public partial class Miniscript<TPk> where TPk : IMiniscriptKey
 	{
-		public Correctness Correctness;
-
-		internal Malleability Malleability;
-
-		public bool IsSubtype(MiniscriptFragmentType other) =>
-			this.Correctness.IsSubtype(other.Correctness) &&
-			this.Malleability.IsSubtype(other.Malleability);
-
-		public MiniscriptFragmentType TypeCheck(Terminal fragment, Func<UInt64, MiniscriptFragmentType> child)
-		{
-			throw new Exception(("TODO"));
-		}
-
-	}
-
-	public class Miniscript
-	{
-		internal readonly Terminal Node;
+		internal readonly Terminal<TPk> Node;
 		public readonly MiniscriptFragmentType Type;
 
 		/// <summary>
@@ -111,18 +14,36 @@ public class Miniscript
 		/// <returns></returns>
 		internal readonly ExtData Ext;
 
-		private Miniscript(MiniscriptFragmentType type, Terminal node, ExtData ext)
+		internal Miniscript(MiniscriptFragmentType type, Terminal<TPk> node, ExtData ext)
 		{
 			Type = type;
 			Node = node;
 			Ext = ext;
 		}
 
-		public static Miniscript FromAst(Terminal t) =>
-			new Miniscript(
-				MiniscriptFragmentType.TypeCheck(t, (_) => null),
-				t,
-				ExtData.TypeCheck(t, (_) => null)
-			);
+		public static Miniscript<TPk> FromAst(Terminal<TPk> t)
+		{
+			MiniscriptFragmentType ty = default;
+			ExtData ext = default;
+
+			return
+				new Miniscript<TPk>(
+					ty.TypeCheck(t, (_) => null),
+					t,
+					ext.TypeCheck(t, (_) => null)
+				);
+		}
+
+		public static Miniscript<TPk> Parse(string str)
+		{
+			var inner = MiniscriptDSLParser.ParseDSL<TPk>(str);
+			MiniscriptFragmentType ty = default;
+			ExtData ext = default;
+			new Miniscript<TPk>(ty.TypeCheck<MiniscriptFragmentType, TPk>(inner));
+		}
+
+		public Script Encode() =>
+			Node.ToScript();
+
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
new file mode 100644
index 0000000000..945a9ffc53
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
@@ -0,0 +1,7 @@
+namespace NBitcoin.Scripting.Miniscript
+{
+	internal static partial class MiniscriptDSLParser
+	{
+
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
new file mode 100644
index 0000000000..03ae113b7e
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
@@ -0,0 +1,216 @@
+using System;
+using System.Collections;
+using System.Linq;
+using System.Text.RegularExpressions;
+using NBitcoin.Scripting.Parser;
+using NBitcoin.DataEncoders;
+using System.Collections.Generic;
+using NBitcoin.Scripting.Miniscript;
+using NBitcoin.Scripting.Miniscript.Policy;
+
+namespace NBitcoin.Scripting
+{
+	internal static partial class MiniscriptDSLParser
+	{
+		internal static readonly Parser<char, string> SurroundedByBrackets  =
+				from leftB in Parse.Char('(').Token()
+				from x in Parse.CharExcept(')').Many().Text()
+				from rightB in Parse.Char(')').Token()
+				select x;
+
+		private static string[] SafeSplit(string s)
+		{
+			var parenthCount = 0;
+			var items = new List<string>();
+			var charSoFar = new List<char>();
+			var length = s.Length;
+			for (int i = 0; i < length; i++)
+			{
+				var c = s[i];
+				if (c == '(')
+				{
+					parenthCount++;
+					charSoFar.Add(c);
+				}
+				else if (c == ')')
+				{
+					parenthCount--;
+					charSoFar.Add(c);
+				}
+				else if (parenthCount != 0)
+				{
+					charSoFar.Add(c);
+				}
+
+				if (parenthCount == 0)
+				{
+					if (i == length - 1)
+					{
+						charSoFar.Add(c);
+					}
+					if (c == ',' || i == length - 1)
+					{
+						var charsCopy = new List<char>(charSoFar);
+						charSoFar = new List<char>();
+						var item = new String(charsCopy.ToArray()).Trim();
+						items.Add(item);
+					}
+					else
+					{
+						charSoFar.Add(c);
+					}
+				}
+			}
+			return items.ToArray();
+		}
+
+		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}");
+				}
+			};
+		}
+
+		internal static Parser<char, TPk> TryParseMiniscriptKey<TPk>(string str)
+			where TPk : IMiniscriptKey
+			=> i =>
+			{
+				TPk t = default;
+				if (!t.TryParse(str))
+					return ParserResult<char, TPk>.Failure(i, $"Failed to parse MiniscriptKey {i}");
+				return ParserResult<char, TPk>.Success(i, t);
+			};
+
+		internal static Parser<char, string> ExprP(string name)
+			=>
+			from identifier in Parse.String(name)
+			from x in SurroundedByBrackets
+			select x;
+
+		private static Parser<char, string[]> ExprPMany(string name)
+			=>
+			from x in ExprP(name)
+			select SafeSplit(x);
+
+		private static Parser<char, ConcretePolicy<TPk>> PPubKeyExpr<TPk>()
+			where TPk : IMiniscriptKey
+			=>
+			from pk in ExprP("pk").Then(s => TryParseMiniscriptKey<TPk>(s))
+			select ConcretePolicy<TPk>.NewKey(pk);
+
+		private static Parser<char, ConcretePolicy<TPk>> PSha256Expr<TPk>()
+			where TPk : IMiniscriptKey
+			=>
+			from hash in ExprP("sha256").Then(s => TryConvert(s, uint256.Parse))
+			select ConcretePolicy<TPk>.NewSha256(hash);
+
+		private static Parser<char, ConcretePolicy<TPk>> PHash256Expr<TPk>()
+			where TPk : IMiniscriptKey
+			=>
+			from hash in ExprP("hash256").Then(s => TryConvert(s, uint256.Parse))
+			select ConcretePolicy<TPk>.NewHash256(hash);
+
+		private static Parser<char, ConcretePolicy<TPk>> PRipemd160Expr<TPk>()
+			where TPk : IMiniscriptKey
+			=>
+			from hash in ExprP("ripemd160").Then(s => TryConvert(s, uint160.Parse))
+			select ConcretePolicy<TPk>.NewRipemd160(hash);
+
+		private static Parser<char, ConcretePolicy<TPk>> PHash160Expr<TPk>()
+			where TPk : IMiniscriptKey
+			=>
+			from hash in ExprP("hash160").Then(s => TryConvert(s, uint160.Parse))
+			select ConcretePolicy<TPk>.NewHash160(hash);
+
+		private static Parser<char, ConcretePolicy<TPk>> PAfterExpr<TPk>()
+			where TPk : IMiniscriptKey
+			=>
+			from t in ExprP("after").Then(s => TryConvert(s, UInt32.Parse))
+			select ConcretePolicy<TPk>.NewAfter(t);
+
+		private static Parser<char, ConcretePolicy<TPk>> POlderExpr<TPk>()
+			where TPk : IMiniscriptKey
+			=>
+			from t in ExprP("older").Then(s => TryConvert(s, UInt32.Parse))
+			select ConcretePolicy<TPk>.NewOlder(t);
+
+		private static Parser<char, IEnumerable<TSub>> PSubExprs<TSub>(string name, Func<Parser<char, TSub>> subP) =>
+			from _n in Parse.String(name)
+			from _left in Parse.Char('(')
+			from x in Parse
+				.Ref(subP)
+				.DelimitedBy(Parse.Char(',').Token()).Token()
+			from _right in Parse.Char(')')
+			select x;
+
+		private static Parser<char, ConcretePolicy<TPk>> PAndExpr<TPk>()
+			where TPk : IMiniscriptKey
+			=>
+			from x in PSubExprs("and", DSLParser<TPk>)
+			select ConcretePolicy<TPk>.NewAnd(x);
+
+		private static Parser<char, Tuple<uint, ConcretePolicy<TPk>>> POrWithProb<TPk>()
+			where TPk : IMiniscriptKey
+			=>
+			from x in Parse.Digit.AtLeastOnce().Text()
+				.Then(digitStr => TryConvert(digitStr, UInt32.Parse))
+			from _a in Parse.Char('@')
+			from sub in Parse.Ref(DSLParser<TPk>)
+			select Tuple.Create(x, sub);
+
+		private static Parser<char, Tuple<uint, ConcretePolicy<TPk>>> POrWithoutProb<TPk>()
+			where TPk : IMiniscriptKey
+			=>
+			from sub in Parse.Ref(DSLParser<TPk>)
+			select Tuple.Create(1U, sub);
+
+		private static Parser<char, ConcretePolicy<TPk>> POrExpr<TPk>()
+			where TPk : IMiniscriptKey
+			=>
+			from x in
+				PSubExprs("or", POrWithProb<TPk>)
+				.Or(PSubExprs("or", POrWithoutProb<TPk>))
+			select ConcretePolicy<TPk>.NewOr(x);
+
+		internal static Parser<char, ConcretePolicy<TPk>> PThresholdExpr<TPk>()
+			where TPk : IMiniscriptKey
+			=>
+				from _n in Parse.String("thres")
+				from _left in Parse.Char('(')
+				from numStr in Parse.Digit.AtLeastOnce().Text()
+				from _sep in Parse.Char(',')
+				from num in TryConvert(numStr, UInt32.Parse)
+				from x in Parse
+					.Ref(DSLParser<TPk>)
+					.DelimitedBy(Parse.Char(',').Token()).Token()
+				from _right in Parse.Char(')')
+				where num <= x.Count()
+				select ConcretePolicy<TPk>.NewThreshold(num, x.ToArray());
+
+		internal static Parser<char, ConcretePolicy<TPk>> DSLParser<TPk>()
+				where TPk : IMiniscriptKey
+				=>
+				(PPubKeyExpr<TPk>()
+					.Or(PAfterExpr<TPk>())
+					.Or(POlderExpr<TPk>())
+					.Or(PSha256Expr<TPk>())
+					.Or(PHash256Expr<TPk>())
+					.Or(PRipemd160Expr<TPk>())
+					.Or(PHash160Expr<TPk>())
+					.Or(PAndExpr<TPk>())
+					.Or(POrExpr<TPk>())
+					.Or(PThresholdExpr<TPk>())).Token();
+
+		public static ConcretePolicy<TPk> ParseDSL<TPk>(string input)
+			where TPk : IMiniscriptKey
+			=> DSLParser<TPk>().Parse(input);
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptError.cs b/NBitcoin/Scripting/Miniscript/MiniscriptError.cs
new file mode 100644
index 0000000000..ac672f5e8d
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptError.cs
@@ -0,0 +1,276 @@
+using System;
+
+namespace NBitcoin.Scripting.Miniscript
+{
+	public class MiniscriptError : Exception
+	{
+		public class ErrorKind
+		{
+			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 ErrorKind UnexpectedStart = new ErrorKind(Tags.UnexpectedStart);
+
+			/// <summary>
+			/// Fragment was an `and_v(_, true)` which should be written as `t:`
+			/// </summary>
+			public static ErrorKind NonCanonicalTrue = new ErrorKind(Tags.NonCanonicalTrue);
+
+			/// <summary>
+			/// NFragment was an `or_i(_, false)` or `or_i(false, _)` which should be written as `u:` or `l:`
+			/// </summary>
+			public static ErrorKind NonCanonicalFalse = new ErrorKind(Tags.NonCanonicalFalse);
+
+			/// <summary>
+			/// Encountered a `l:0` which is syntactically equal to `u:0` except stupid
+			/// </summary>
+			public static ErrorKind LikelyFalse = new ErrorKind(Tags.LikelyFalse);
+
+			/// <summary>
+			/// General failure to satisfy
+			/// </summary>
+			public static ErrorKind CouldNotSatisfy = new ErrorKind(Tags.CouldNotSatisfy);
+
+			/// <summary>
+			/// General error in creating descriptor
+			/// </summary>
+			public static ErrorKind BadDescriptor = new ErrorKind(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 ErrorKind BadScriptSig = new ErrorKind(Tags.BadScriptSig);
+
+			/// <summary>
+			/// Witness must be empty for pre-segwit transactions
+			/// </summary>
+			public static ErrorKind NonEmptyWitness = new ErrorKind(Tags.NonEmptyWitness);
+
+			/// <summary>
+			/// ScriptSig must be empty for pure segwit transactions.
+			/// </summary>
+			public static ErrorKind NonEmptyScriptSig = new ErrorKind(Tags.NonEmptyScriptSig);
+
+			/// <summary>
+			/// Incorrect Script Pubkey Hash for the descriptor. This is used for both
+			/// `PkH` and `Wpkh` descriptors.
+			/// </summary>
+			public static ErrorKind IncorrectPubkeyHash = new ErrorKind(Tags.IncorrectPubkeyHash);
+
+			/// <summary>
+			/// Incorrect Script pubkey Hash for the descriptor. This is used for both
+			/// `Sh` and `Wsh` descriptors.
+			/// </summary>
+			public static ErrorKind IncorrectScriptHash = new ErrorKind(Tags.IncorrectScriptHash);
+
+			private ErrorKind(int tag) => Tag = tag;
+
+			/// <summary>
+			/// Opcode appeared which is not part of the script subset.
+			/// </summary>
+			internal class InvalidOpcode : ErrorKind
+			{
+				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 : ErrorKind
+			{
+				public ScriptToken Item;
+				public NonMinimalVerify(ScriptToken item) : base(Tags.NonMinimalVerify) => Item = item;
+			}
+
+			/// <summary>
+			/// Push was illegal in some context
+			/// </summary>
+			internal class InvalidPush : ErrorKind
+			{
+				public byte[] Item;
+				public InvalidPush(byte[] item) : base(Tags.InvalidPush) => Item = item;
+			}
+
+			/// <summary>
+			///  PSBT related error
+			/// </summary>
+			internal class PSBT : ErrorKind
+			{
+				public PSBTError Item;
+				public PSBT(PSBTError item) : base(Tags.PSBT) => Item = item;
+			}
+
+			internal class Script : ErrorKind
+			{
+				public ScriptError Item;
+				public Script(ScriptError item) : base(Tags.Script) => Item = item;
+			}
+
+			internal class CmsTooManyKeys : ErrorKind
+			{
+				public uint Item;
+
+				public CmsTooManyKeys(uint item) : base(Tags.CmsTooManyKeys) => Item = item;
+			}
+
+			internal class Unprintable : ErrorKind
+			{
+				public byte Item;
+
+				public Unprintable(byte item) : base (Tags.Unprintable) => Item = item;
+			}
+
+			internal class ExpectedChar : ErrorKind
+			{
+				public char Item;
+
+				public ExpectedChar(char item) : base(Tags.ExpectedChar) => Item = item;
+			}
+
+			internal class Unexpected : ErrorKind
+			{
+				public string Item;
+
+				public Unexpected(string item) : base(Tags.Unexpected) => Item = item;
+			}
+
+			internal class MultiColon : ErrorKind
+			{
+				public string Item;
+
+				public MultiColon(string item) : base(Tags.MultiColon) => Item = item;
+			}
+
+			internal class MultiAt : ErrorKind
+			{
+				public string Item;
+				internal MultiAt(string item) : base(Tags.MultiAt) => Item = item;
+			}
+
+			internal class AtOutsideOr : ErrorKind
+			{
+				public string Item;
+				internal AtOutsideOr(string item) : base(Tags.AtOutsideOr) => Item = item;
+			}
+
+			internal class UnknownWrapper : ErrorKind
+			{
+				public char Item;
+				public UnknownWrapper(char item) : base(Tags.UnknownWrapper) => Item = item;
+			}
+
+			internal class NonTopLevel : ErrorKind
+			{
+				public string Item;
+				public NonTopLevel(string item) : base(Tags.NonTopLevel) => Item = item;
+			}
+
+			internal class Trailing : ErrorKind
+			{
+				public string Item;
+				public Trailing(string item) : base(Tags.Trailing) => Item = item;
+			}
+
+			internal class BadPubKey : ErrorKind
+			{
+				public FormatException Item;
+				public BadPubKey(FormatException item) : base(Tags.BadPubKey) => Item = item;
+			}
+
+			internal class MissingHash : ErrorKind
+			{
+				public uint256 Item;
+
+				public MissingHash(uint256 item) : base(Tags.MissingHash) => Item = item;
+			}
+
+			internal class MissingSig : ErrorKind
+			{
+				public PubKey Item;
+
+				public MissingSig(PubKey item) : base(Tags.MissingSig) => Item = item;
+			}
+
+			internal class RelativeLockTimeNotMet : ErrorKind
+			{
+				public uint Item;
+				public RelativeLockTimeNotMet(uint item) : base(Tags.RelativeLocktimeNotMet) => Item = item;
+			}
+
+			internal class AbsoluteLockTimeNotMet : ErrorKind
+			{
+				public uint Item;
+				public AbsoluteLockTimeNotMet(uint item) : base(Tags.AbsoluteLockTimeNotMet) => Item = item;
+			}
+
+			internal class TypeCheck : ErrorKind
+			{
+				public string Item;
+				public TypeCheck(string item) : base(Tags.TypeCheck) => Item = item;
+			}
+
+			internal class CompileError : ErrorKind
+			{
+				public Policy.CompilerException Item;
+
+				public CompileError(Policy.CompilerException item) : base (Tags.CompileError) => Item = item;
+			}
+
+			internal class InterpreterError : ErrorKind
+			{
+				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
index 3c67c92b94..f2e4259cbc 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
@@ -1,7 +1,37 @@
+using System;
+
 namespace NBitcoin.Scripting.Miniscript
 {
-	public class MiniscriptKey
+	public interface IMiniscriptKeyHash
 	{
-		
+		uint160 ToHash160();
 	}
+
+	/// <summary>
+	/// Interface to abstract PubKey in Miniscript
+	/// </summary>
+	public interface IMiniscriptKey
+	{
+		IMiniscriptKeyHash MiniscriptKeyHash { get; }
+
+		/// <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 TryParse(string str);
+
+		bool Equals(IMiniscriptKey other);
+	}
+
 }
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs b/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
index f665ab5a29..907b31d530 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
@@ -1,5 +1,9 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Net;
+using System.Runtime.InteropServices.ComTypes;
+using NBitcoin.Scripting.Miniscript.Types;
 using NBitcoin.Scripting.Parser;
 
 using P = NBitcoin.Scripting.Parser.Parser<NBitcoin.Scripting.Miniscript.ScriptToken, NBitcoin.Scripting.Miniscript.Miniscript>;
@@ -391,8 +395,72 @@ public static AstElem ParseScript(Script sc)
 			=> PT.Parse(sc);
 		*/
 
-		private static readonly P
 
 		public static Terminal ParseScript(Script sc) =>
+			throw new NotImplementedException();
+
+		private class TerminalStack
+		{
+			internal readonly Stack<Miniscript> Inner;
+			internal TerminalStack(Stack<Miniscript> inner)
+			{
+				Inner = inner;
+			}
+
+			internal Miniscript Pop() =>
+				this.Inner.Pop();
+
+			internal void Reduce0(Terminal ms)
+			{
+				MiniscriptFragmentType ty = default;
+				ty = ty.TypeCheck(ms, _ => null);
+				ExtData ext = default;
+				ext = ext.TypeCheck(ms, _ => null);
+				this.Inner.Push(new Miniscript(ty, ms, ext));
+			}
+
+			internal void Reduce1(Func<Miniscript, Terminal> wrap)
+			{
+				var top = this.Pop();
+				var wrappedMs = wrap(top);
+				var ty = MiniscriptFragmentType.TypeCheck(wrappedMs, _ => null);
+				var ext = ExtData.TypeCheck(wrappedMs, _ => null);
+				this.Inner.Push(new Miniscript(ty, wrappedMs, ext));
+			}
+
+			internal void Reduce2(Func<Miniscript, Miniscript, Terminal> wrap)
+			{
+				var left = this.Pop();
+				var right = this.Pop();
+				var wrappedMs = wrap(left, right);
+				var ty = MiniscriptFragmentType.TypeCheck(wrappedMs, _ => null);
+				var ext = ExtData.TypeCheck(wrappedMs, _ => null);
+				this.Inner.Push(new Miniscript(ty, wrappedMs, ext));
+			}
+		}
+
+		private static T MatchToken<T>(Func<T> f) => f.Invoke();
+
+		private static void MatchToken(ScriptToken tokens)
+		{
+			throw new NotImplementedException();
+		}
+		public static Miniscript<TPk> ParseScriptToken(ScriptToken sct)
+		{
+			var nonTerm = new Stack<NonTerm>();
+			var term = new TerminalStack(new Stack<Miniscript>());
+
+			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)
+				{}
+			}
+		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
new file mode 100644
index 0000000000..916cbd5df7
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
@@ -0,0 +1,328 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NBitcoin.BouncyCastle.Asn1;
+using NBitcoin.BouncyCastle.Math.EC.Multiplier;
+using NBitcoin.RPC;
+
+namespace NBitcoin.Scripting.Miniscript.Policy
+{
+	public class AbstractPolicy<TPk> : IEquatable<AbstractPolicy<TPk>> where TPk : IMiniscriptKey
+	{
+		#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> UnSatisfiable { get; } = new AbstractPolicy<TPk>(Tags.Unsatisfiable);
+		public static AbstractPolicy<TPk> Trivial { get; } = new AbstractPolicy<TPk>(Tags.Trivial);
+
+		internal class KeyHash : AbstractPolicy<TPk>
+		{
+			internal IMiniscriptKeyHash Item;
+			internal KeyHash(IMiniscriptKeyHash item) : base(Tags.KeyHash)
+			{
+				Item = item;
+			}
+		}
+
+		internal class After : AbstractPolicy<TPk>
+		{
+			internal uint Item;
+
+			public After(uint item) : base (Tags.After)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Older : AbstractPolicy<TPk>
+		{
+			internal uint Item;
+
+			public Older(uint item) : base (Tags.Older)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Sha256 : AbstractPolicy<TPk>
+		{
+			internal uint256 Item;
+
+			public Sha256(uint256 item) :base(Tags.Sha256)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Hash256 : AbstractPolicy<TPk>
+		{
+			internal uint256 Item;
+
+			public Hash256(uint256 item) :base(Tags.Hash256)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Ripemd160 : AbstractPolicy<TPk>
+		{
+			internal uint160 Item;
+
+			public Ripemd160(uint160 item) :base(Tags.Ripemd160)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Hash160 : AbstractPolicy<TPk>
+		{
+			internal uint160 Item;
+
+			public Hash160(uint160 item) :base(Tags.Hash160)
+			{
+				Item = item;
+			}
+		}
+
+		internal class And : AbstractPolicy<TPk>
+		{
+			internal List<AbstractPolicy<TPk>> Item;
+
+			public And(List<AbstractPolicy<TPk>> item) : base(Tags.And)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Or : AbstractPolicy<TPk>
+		{
+			internal List<AbstractPolicy<TPk>> Item;
+
+			public Or(List<AbstractPolicy<TPk>> item) : base(Tags.Or)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Threshold : AbstractPolicy<TPk>
+		{
+			internal uint Item1;
+			internal List<AbstractPolicy<TPk>> Item2;
+
+			public Threshold(uint item1, List<AbstractPolicy<TPk>> item2) : base (Tags.Threshold)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+
+		public static AbstractPolicy<TPk> NewUnsatisfiable() => UnSatisfiable;
+		public static AbstractPolicy<TPk> NewTrivial() => Trivial;
+		public static AbstractPolicy<TPk> NewKeyHash(IMiniscriptKeyHash item) => new KeyHash(item);
+		public static AbstractPolicy<TPk> NewAfter(uint item) => new After(item);
+		public static AbstractPolicy<TPk> NewOlder(uint item) => new Older(item);
+		public static AbstractPolicy<TPk> NewSha256(uint256 item) => new Sha256(item);
+		public static AbstractPolicy<TPk> NewHash256(uint256 item) => new Hash256(item);
+		public static AbstractPolicy<TPk> NewRipemd160(uint160 item) => new Ripemd160(item);
+		public static AbstractPolicy<TPk> NewHash160(uint160 item) => new Hash160(item);
+		public static AbstractPolicy<TPk> NewAnd(List<AbstractPolicy<TPk>> item) => new And(item);
+		public static AbstractPolicy<TPk> NewOr(List<AbstractPolicy<TPk>> item) => new Or(item);
+		public static AbstractPolicy<TPk> NewThreshold(uint item1, List<AbstractPolicy<TPk>> item2) => new Threshold(item1, item2);
+
+		#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> 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>>(self.Item);
+					return andSet.SetEquals(((And)other).Item);
+				case Or self:
+					var orSet = new HashSet<AbstractPolicy<TPk>>(self.Item);
+					return orSet.SetEquals(((Or)other).Item);
+				case Threshold self:
+					var subSet = new HashSet<AbstractPolicy<TPk>>(self.Item2);
+					var o = (Threshold) other;
+					return (self.Item1 == o.Item1) && (subSet.SetEquals(o.Item2));
+			}
+			throw new Exception("Unreachable!");
+		}
+
+		#endregion
+
+		public static AbstractPolicy<TPk> FromTree<T>(Tree<T> top)
+		{
+			var n = top.Name;
+			var l = top.Args.Length;
+			if (n == "UNSATISFIABLE" && l == 0)
+				return AbstractPolicy<TPk>.UnSatisfiable;
+			if (n == "TRIVIAL" && l == 0)
+				return AbstractPolicy<TPk>.Trivial;
+			//if (n == "pkh" && l == 1)
+				// return AbstractPolicy<TPk>.KeyHash;
+			throw new NotImplementedException();
+		}
+
+		/// <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> Normalize()
+		{
+			switch (this)
+			{
+				case And self:
+					var retSubsAnd = new List<AbstractPolicy<TPk>>();
+					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>>();
+					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;
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index fc7acbfb8e..04c9fcbbb7 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -1,10 +1,17 @@
 using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices.ComTypes;
+using NBitcoin.Scripting.Miniscript.Types;
 
 namespace NBitcoin.Scripting.Miniscript.Policy
 {
 	public class CompilerException : Exception
 	{}
 
+	/// <summary>
+	/// This represents the state of the best possible compilation
+	/// of a given policy(implicitly keyed).
+	/// </summary>
 	internal class CompilationKey
 	{
 		/// <summary>
@@ -28,7 +35,9 @@ internal class CompilationKey
 		internal readonly double? DissatProb;
 
 		public bool IsSubtype(CompilationKey other) =>
-			this.Type.IsSubtype(other.Type);
+			this.Type.IsSubtype(other.Type) &&
+			this.ExpensiveVerify == other.ExpensiveVerify &&
+			this.DissatProb == other.DissatProb;
 
 		private CompilationKey(MiniscriptFragmentType type, double? dissatProb, bool expensiveVerify)
 		{
@@ -39,35 +48,150 @@ private CompilationKey(MiniscriptFragmentType type, double? dissatProb, bool exp
 
 	}
 
-	internal class CompilerExtData
+	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;
+		internal readonly 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 double SatisfyCost;
-		internal double? DissatCost;
+		internal readonly double SatisfyCost;
+		internal readonly double? DissatCost;
 	}
 
-	internal class AstElemExt
+	internal class AstElemExt<TPk> where TPk : IMiniscriptKey
 	{
-		internal Miniscript Ms;
-		internal CompilerExtData CompilerExtData;
+		internal readonly Miniscript<TPk> Ms;
+		internal readonly CompilerExtData CompExtData;
 
-		internal double CostLd(double satProb, double? dissatProb)
+		public AstElemExt(CompilerExtData compilerExtData, Miniscript<TPk> ms)
 		{
-			return this.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
+				(double)this.Ms.Ext.PkCost +
+				(this.CompExtData.SatisfyCost * satProb) +
+				dissatCost;
+
+		}
+
+		internal static AstElemExt<TPk> Terminal(Terminal<TPk> ast)
+		{
+			CompilerExtData compExtData = default;
+			Miniscript<TPk> ms = default;
+			return new AstElemExt<TPk>(compExtData.TypeCheck(ast), Miniscript<TPk>.FromAst(ast));
+		}
+
+		internal static AstElemExt<TPk> Binary(Terminal<TPk> ast, AstElemExt<TPk> l, AstElemExt<TPk> r)
+		{
+			MiniscriptFragmentType ty = default;
+			ty = ty.TypeCheck(ast);
+			ExtData ext = default;
+			ext = ext.TypeCheck(ast);
+
+			Func<int, CompilerExtData> lookupExt =
+				(int n) => n == 0 ? l.CompExtData : n == 1 ? r.CompExtData : throw new Exception("Unreachable");
+			CompilerExtData compExtData = default;
+			compExtData = compExtData.TypeCheck(ast, lookupExt);
+
+			return new AstElemExt<TPk>(compExtData, new Miniscript<TPk>(ty, ast, ext));
+		}
+
+		internal static AstElemExt<TPk> Ternary(
+			Terminal<TPk> ast,
+			AstElemExt<TPk> a,
+			AstElemExt<TPk> b,
+			AstElemExt<TPk> c
+		)
+		{
+			Func<int, CompilerExtData> lookupExt =
+				n =>
+					n == 0 ? a.CompExtData :
+					n == 1 ? b.CompExtData :
+					n == 2 ? c.CompExtData :
+					throw new Exception("Unreachable");
+
+			MiniscriptFragmentType ty = default;
+			ty = ty.TypeCheck(ast);
+			ExtData ext = default;
+			ext = ext.TypeCheck(ast);
+			CompilerExtData compilerExtData = default;
+			compilerExtData = compilerExtData.TypeCheck(ast, lookupExt);
+
+			return new AstElemExt<TPk>(compilerExtData, new Miniscript<TPk>(ty, ast, ext));
+		}
+	}
+
+	internal class Cast<TPk> where TPk : IMiniscriptKey
+	{
+		public Func<Miniscript<TPk>, Terminal<TPk>> Node;
+		public Func<MiniscriptFragmentType> AstType;
+		public Func<ExtData> ExtData;
+		public Func<CompilerExtData> CompilerExtData;
+
+		public Cast(Func<ExtData> extData, Func<MiniscriptFragmentType> astType, Func<Miniscript<TPk>, Terminal<TPk>> node, Func<CompilerExtData> compilerExtData)
+		{
+			ExtData = extData;
+			AstType = astType;
+			Node = node;
+			CompilerExtData = compilerExtData;
+		}
+
+		public AstElemExt<TPk> InvokeCast(AstElemExt<TPk> ast)
+		=>
+			new AstElemExt<TPk>(
+				ms: new Miniscript<TPk>(
+					this.AstType.Invoke(ast.Ms.Type),
+					this.Node.Invoke(ast.Ms),
+					this.ExtData.Invoke(ast.Ms.Ext)
+
+				),
+				compilerExtData:this.CompilerExtData.Invoke(ast.CompExtData));
+
+		public List<Cast<TPk>> AllCasts()
+		{
+			ExtData extD = default;
+			Terminal<TPk> term = default;
+			MiniscriptFragmentType astType = default;
+			CompilerExtData compilerExtData = default;
+			return
+				new List<Cast<TPk>>()
+				{
+					new Cast<TPk>(
+						extD.CastCheck,
+						astType.TypeCheck,
+						Terminal<TPk>.NewCheck,
+						compilerExtData.CastCheck
+					),
+					new Cast<TPk>()
+				};
 		}
 	}
 
-	public class Compiler
+	public static class Compiler
 	{
 
 	}
diff --git a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
new file mode 100644
index 0000000000..8cb131a7b9
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
@@ -0,0 +1,491 @@
+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> : IEquatable<ConcretePolicy<TPk>>, ILiftable<TPk> where TPk : IMiniscriptKey
+	{
+		#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>
+		{
+			public TPk Item;
+			public Key(TPk item) : base(Tags.Key) => Item = item;
+		}
+
+		internal class After : ConcretePolicy<TPk>
+		{
+			public uint Item;
+
+			public After(uint item) : base(Tags.After) => Item = item;
+		}
+
+		internal class Older : ConcretePolicy<TPk>
+		{
+			public uint Item;
+
+			public Older(uint item) : base(Tags.Older) => Item = item;
+		}
+
+		internal class Sha256 : ConcretePolicy<TPk>
+		{
+			public uint256 Item;
+
+			public Sha256(uint256 item) : base(Tags.Sha256) => Item = item;
+		}
+
+		internal class Hash256 : ConcretePolicy<TPk>
+		{
+			public uint256 Item;
+
+			public Hash256(uint256 item) : base(Tags.Hash256) => Item = item;
+		}
+
+		internal class Ripemd160 : ConcretePolicy<TPk>
+		{
+			public uint160 Item;
+
+			public Ripemd160(uint160 item) : base(Tags.Ripemd160) => Item = item;
+		}
+
+		internal class Hash160 : ConcretePolicy<TPk>
+		{
+			public uint160 Item;
+			public Hash160(uint160 item) : base(Tags.Hash160) => Item = item;
+		}
+
+		internal class And : ConcretePolicy<TPk>
+		{
+			public List<ConcretePolicy<TPk>> Item;
+
+			public And(List<ConcretePolicy<TPk>> item) : base(Tags.And)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Or : ConcretePolicy<TPk>
+		{
+			public List<Tuple<uint, ConcretePolicy<TPk>>> Item;
+
+			public Or(List<Tuple<uint, ConcretePolicy<TPk>>> item) : base(Tags.Or)
+			{
+				Item = item;
+			}
+		}
+
+		internal class Threshold : ConcretePolicy<TPk>
+		{
+			public uint Item1;
+			public List<ConcretePolicy<TPk>> Item2;
+
+			public Threshold(uint item1, List<ConcretePolicy<TPk>> item2) : base(Tags.Threshold)
+			{
+				Item1 = item1;
+				Item2 = item2;
+			}
+		}
+
+		public static ConcretePolicy<TPk> NewKey(TPk pk) => new Key(pk);
+		public static ConcretePolicy<TPk> NewAfter(uint time) => new After(time);
+		public static ConcretePolicy<TPk> NewOlder(uint item) => new Older(item);
+		public static ConcretePolicy<TPk> NewSha256(uint256 item) => new Sha256(item);
+		public static ConcretePolicy<TPk> NewHash256(uint256 item) => new Hash256(item);
+		public static ConcretePolicy<TPk> NewRipemd160(uint160 item) => new Ripemd160(item);
+		public static ConcretePolicy<TPk> NewHash160(uint160 item) => new Hash160(item);
+		public static ConcretePolicy<TPk> NewAnd(IEnumerable<ConcretePolicy<TPk>> subs) => new And(subs.ToList());
+		public static ConcretePolicy<TPk> NewOr(IEnumerable<Tuple<uint, ConcretePolicy<TPk>>> item) => new Or(item.ToList());
+		public static ConcretePolicy<TPk> NewThreshold(uint k, IEnumerable<ConcretePolicy<TPk>> subs) => new Threshold(k, subs.ToList());
+
+		#endregion
+
+
+		#region Equatable members
+
+		public bool Equals(ConcretePolicy<TPk> 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:
+					var andSet = new HashSet<ConcretePolicy<TPk>>(self.Item);
+					return andSet.SetEquals(((And)other).Item);
+				case Or self:
+					var orSet = new HashSet<Tuple<uint, ConcretePolicy<TPk>>>(self.Item);
+					return orSet.SetEquals(((Or)other).Item);
+				case Threshold self:
+					var thres = (Threshold) other;
+					var threshSet = new HashSet<ConcretePolicy<TPk>>(self.Item2);
+					return self.Item1 == thres.Item1 && threshSet.SetEquals(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 + self.Item.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 AbstractPolicy<TPk> Lift()
+		{
+			AbstractPolicy<TPk> res = null;
+			switch (this)
+			{
+				case Key self:
+					res = AbstractPolicy<TPk>.NewKeyHash(self.Item.MiniscriptKeyHash);
+					break;
+				case After self:
+					res = AbstractPolicy<TPk>.NewAfter(self.Item);
+					break;
+				case Older self:
+					res = AbstractPolicy<TPk>.NewOlder(self.Item);
+					break;
+				case Sha256 self:
+					res = AbstractPolicy<TPk>.NewSha256(self.Item);
+					break;
+				case Hash256 self:
+					res = AbstractPolicy<TPk>.NewHash256(self.Item);
+					break;
+				case Ripemd160 self:
+					res = AbstractPolicy<TPk>.NewRipemd160(self.Item);
+					break;
+				case Hash160 self:
+					res = AbstractPolicy<TPk>.NewHash160(self.Item);
+					break;
+				case And self:
+					res = AbstractPolicy<TPk>.NewAnd(self.Item.Select(sub => sub.Lift()).ToList());
+					break;
+				case Or self:
+					res = AbstractPolicy<TPk>.NewOr(self.Item.Select(sub => sub.Item2.Lift()).ToList());
+					break;
+				case Threshold self:
+					res = AbstractPolicy<TPk>.NewThreshold(self.Item1, self.Item2.Select(sub => sub.Lift()).ToList());
+					break;
+			}
+
+			return res.Normalize();
+
+		}
+
+		public override bool Equals(object obj) =>
+			Equals(obj as ConcretePolicy<TPk>);
+
+		#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 IsValid()
+		{
+			switch (this)
+			{
+				case And self:
+					if (self.Item.Count != 2)
+						throw PolicyException.NonBinaryArgAnd;
+					return self.Item.All(sub => sub.IsValid());
+				case Or self:
+					if (self.Item.Count != 2)
+						throw PolicyException.IncorrectThresh;
+					return self.Item.All(sub => sub.Item2.IsValid());
+				case Threshold self:
+					if (self.Item1 <= 0 || self.Item1 > self.Item2.Count)
+						throw PolicyException.IncorrectThresh;
+					return self.Item2.All(sub => sub.IsValid());
+				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 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)
+						{
+							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> FromTree()
+		{
+
+			throw new NotImplementedException("");
+		}
+
+		private static Tuple<uint, ConcretePolicy<TPk>> FromTreeProb<T>(Tree<T> top, bool allowProb)
+		{
+			int fragProb = default;
+			string fragName = default;
+			var nameSplit = top.Name.Split('@');
+			if (nameSplit.Length == 0)
+			{
+				fragProb = 1;
+				fragName = "";
+			}
+			else if (nameSplit.Length == 1)
+			{
+				fragProb = 1;
+				fragName = nameSplit[0];
+			}
+			else if (nameSplit.Length == 2)
+			{
+				if (!allowProb)
+					throw new ParsingException("we found @ in outside of `or` expression");
+				fragProb = Int32.Parse(nameSplit[0]);
+				fragName = nameSplit[1];
+			}
+			else
+			{
+				throw new ParsingException("We found more than one @ in expression");
+			}
+
+			throw new NotImplementedException();
+			// if (fragName == "pk" && top.Args.Length == 1)
+
+		}
+	}
+}
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/Property.cs b/NBitcoin/Scripting/Miniscript/Property.cs
index 8e8e92e6f4..08b060a601 100644
--- a/NBitcoin/Scripting/Miniscript/Property.cs
+++ b/NBitcoin/Scripting/Miniscript/Property.cs
@@ -1,7 +1,3 @@
 namespace NBitcoin.Scripting.Miniscript
 {
-	public interface Property
-	{
-		
-	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Tree.cs b/NBitcoin/Scripting/Miniscript/Tree.cs
index 638559b4db..20dd08a5af 100644
--- a/NBitcoin/Scripting/Miniscript/Tree.cs
+++ b/NBitcoin/Scripting/Miniscript/Tree.cs
@@ -1,3 +1,6 @@
+using System;
+using NBitcoin.Scripting.Parser;
+
 namespace NBitcoin.Scripting.Miniscript
 {
 	/// <summary>
@@ -9,9 +12,32 @@ public class Tree<T>
 		public readonly string Name;
 		public readonly Tree<T>[] Args;
 
+		/// <summary>
+		/// Attempts to parse a terminal expression.
+		/// </summary>
+		/// <param name="str"></param>
+		/// <returns></returns>
+		public static T Terminal(Tree<T> term, Func<string, T> converter)
+		{
+			if (term.Args.Length == 0)
+				converter.Invoke(term.Name);
+			throw new ParsingException(term.Name);
+		}
+
 		public static Tree<T> Parse(string str)
 		{
-			throw new System.Exception("");
+			var topAndRemaining = FromSlice(str);
+			var top = topAndRemaining.Item1;
+			var remaining = topAndRemaining.Item2;
+			if (remaining.Length == 0)
+				throw new NotImplementedException();
+			else
+				throw new ParsingException(remaining);
+		}
+
+		private static Tuple<Tree<T>, string> FromSlice(string str)
+		{
+			throw new NotImplementedException();
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
new file mode 100644
index 0000000000..bb6026ce30
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
@@ -0,0 +1,188 @@
+using System;
+using NBitcoin.Scripting.Miniscript.Policy;
+
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+	public class Correctness : IProperty<Correctness>
+	{
+		public Base Base;
+		public Input Input;
+		public bool DisSatisfiable;
+		/// <summary>
+		/// Whether the fragment's "nonzero' output on satisfaction is
+		/// always the constant 1.
+		/// </summary>
+		public bool Unit;
+
+		public bool IsSubtype(Correctness other) =>
+			(this.Base == other.Base) &&
+			(this.Input.IsSubtype(other.Input)) &&
+			(!(!(this.DisSatisfiable) && other.DisSatisfiable)) &&
+			(!(!(this.Unit) && other.Unit));
+
+		public void SanityChecks()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness FromTrue()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness FromFalse()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness FromPk()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness FromPkH()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness FromMulti(int k, int pkLength)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness FromAfter(uint time)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness FromOlder(uint time)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness FromHash()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness FromSha256()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness FromHash256()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness FromRipemd160()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness FromHash160()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness CastAlt()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness CastSwap()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness CastCheck()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness CastDupIf()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness CastVerify()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness CastNonZero()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness CastZeroNotEqual()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness CastTrue()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness CastOrIFalse()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness CastUnLikely()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness CastLikely()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness AndB(Correctness left, Correctness right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness AndV(Correctness left, Correctness right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness AndN(Correctness left, Correctness right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness OrB(Correctness left, Correctness right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness OrD(Correctness left, Correctness right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness OrC(Correctness left, Correctness right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness OrI(Correctness left, Correctness right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness AndOr(Correctness a, Correctness b, Correctness c)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Correctness Threshold(int k, int n, Func<uint, Correctness> subCk)
+		{
+			throw new NotImplementedException();
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/ExtData.cs b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
index b6cd0ee040..047b3eb27e 100644
--- a/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
@@ -10,7 +10,7 @@ internal enum LegacySafe
 		LegacySafe,
 		SegwitOnly
 	}
-	internal class ExtData
+	internal class ExtData : IProperty<ExtData>
 	{
 		internal LegacySafe LegacySafe;
 		internal UInt64 PkCost;
@@ -19,16 +19,169 @@ internal class ExtData
 		internal UInt64?  OpsCountSat;
 		internal UInt64? OpsCountNSat;
 
-		/// <summary>
-		///  Compute the type of a fragment, given a function to lookup
-		/// the types of its children, if available and relevant for the given fragment.
-		/// </summary>
-		/// <param name="fragment"></param>
-		/// <param name="child"></param>
-		/// <returns></returns>
-		internal static ExtData TypeCheck(Terminal fragment, Func<UInt64, ExtData> child)
+		public void SanityChecks()
 		{
-			throw new System.Exception("TODO");
+			throw new NotImplementedException();
+		}
+
+		public ExtData FromTrue()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData FromFalse()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData FromPk()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData FromPkH()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData FromMulti(int k, int pkLength)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData FromAfter(uint time)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData FromOlder(uint time)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData FromHash()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData FromSha256()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData FromHash256()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData FromRipemd160()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData FromHash160()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData CastAlt()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData CastSwap()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData CastCheck()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData CastDupIf()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData CastVerify()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData CastNonZero()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData CastZeroNotEqual()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData CastTrue()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData CastOrIFalse()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData CastUnLikely()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData CastLikely()
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData AndB(ExtData left, ExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData AndV(ExtData left, ExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData AndN(ExtData left, ExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData OrB(ExtData left, ExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData OrD(ExtData left, ExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData OrC(ExtData left, ExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData OrI(ExtData left, ExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData AndOr(ExtData a, ExtData b, ExtData c)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ExtData Threshold(int k, int n, Func<uint, ExtData> subCk)
+		{
+			throw new NotImplementedException();
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
new file mode 100644
index 0000000000..c671ad146a
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
@@ -0,0 +1,306 @@
+using System;
+using System.Linq;
+
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+	public interface IProperty<T> where T: IProperty<T>
+	{
+		void SanityChecks();
+		T FromTrue();
+		T FromFalse();
+		T FromPk();
+		T FromPkH();
+		T FromMulti(int k, int pkLength);
+		T FromAfter(uint time);
+		T FromOlder(uint time);
+		T FromHash();
+		T FromSha256();
+		T FromHash256();
+		T FromRipemd160();
+		T FromHash160();
+
+		T CastAlt();
+		T CastSwap();
+		T CastCheck();
+		T CastDupIf();
+		T CastVerify();
+		T CastNonZero();
+		T CastZeroNotEqual();
+		T CastTrue();
+		T CastOrIFalse();
+		T CastUnLikely();
+		T CastLikely();
+		T AndB(T left, T right);
+		T AndV(T left, T right);
+		T AndN(T left, T right);
+		T OrB(T left, T right);
+		T OrD(T left, T right);
+		T OrC(T left, T right);
+		T OrI(T left, T right);
+		T AndOr(T a, T b, T c);
+		T Threshold(int k, int n, Func<uint, T> subCk);
+	}
+
+	public enum ErrorKind
+	{
+		/// <summary>
+		/// Relative or absolute timelock had a time value of 0;
+		/// </summary>
+		ZeroTime,
+
+		/// <summary>
+		/// Passed a `z` argument to a `d` wrapper when `z` was expected
+		/// </summary>
+		NonZeroDupIf,
+
+		/// <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>
+		/// 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>
+		/// Tried to use the `s:` modifier on a fragment that takes more
+		/// than one input.
+		/// </summary>
+		SwapNonOne,
+		/// <summary>
+		/// Tried to use `s:` modifier on a fragment that takes more than one input
+		/// </summary>
+		NonZeroZero,
+
+		/// <summary>
+		/// Many fragments require their left child to be a unit. This
+		/// was not the case.
+		/// </summary>
+		LeftNotUnit,
+
+		/// <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>
+		/// 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,
+
+		/// <summary>
+		/// Insufficiently many children of a threshold fragment were strong
+		/// </summary>
+		ThresholdNotStrong
+	}
+
+	class TypeCheckException<TPk> : Exception where TPk : IMiniscriptKey
+	{
+		public readonly Terminal<TPk> Fragment;
+		public readonly ErrorKind Kind;
+		public readonly int[] Items;
+		public TypeCheckException(Terminal<TPk> fragment, ErrorKind kind)
+			: this(fragment, kind, new int[] { })
+		{}
+
+		public TypeCheckException(Terminal<TPk> fragment, ErrorKind kind, int[] items):
+			base($"Error: {kind.ToString("G")}. Fragment: {fragment}, items: {items.Select(i => i.ToString()).Aggregate((str, i) => $"{str}, {i}")}")
+
+		{
+			Fragment = fragment;
+			Kind = kind;
+			Items = items;
+		}
+
+		public TypeCheckException(string msg): base(msg) {}
+		public TypeCheckException(string msg, Exception innerException): base(msg, innerException) {}
+	}
+
+	public static class PropertyExtensions
+	{
+		/// <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>
+		/// <param name="prop"></param>
+		/// <param name="fragment"></param>
+		/// <param name="child"></param>
+		/// <typeparam name="T"></typeparam>
+		/// <exception cref="TypeCheckException"></exception>
+		/// <returns></returns>
+		internal static T TypeCheck<T, TPk>(this T prop, Terminal<TPk> fragment, Func<int, T> child) where T : class, IProperty<T>
+		where TPk : IMiniscriptKey
+		{
+			var res = prop.TypeCheckCore(fragment, child);
+			res.SanityChecks();
+			return res;
+		}
+
+		internal static T TypeCheck<T, TPk>(this T prop, Terminal<TPk> fragment) where T : class, IProperty<T>
+			where TPk : IMiniscriptKey
+			=> prop.TypeCheck(fragment, (_) => null);
+
+		private static T TypeCheckCore<T, TPk>(this T prop, Terminal<TPk> fragment,Func<int, T> child) where T : class, IProperty<T>
+		where TPk : IMiniscriptKey
+		{
+			T GetChild(Terminal<TPk> sub, int n)
+				{
+					try
+					{
+						return child(n);
+					}
+					catch
+					{
+						return prop.TypeCheck(sub, _ => null);
+					}
+				}
+			switch (fragment.Tag)
+			{
+				case Terminal<TPk>.Tags.True:
+					return prop.FromTrue();
+				case Terminal<TPk>.Tags.False:
+					return prop.FromFalse();
+			}
+
+			switch (fragment)
+			{
+				case Terminal<TPk>.Pk self:
+					return prop.FromPk();
+				case Terminal<TPk>.PkH self:
+					return prop.FromPkH();
+				case Terminal<TPk>.ThreshM self:
+					if (self.Item1 == 0)
+					{
+						throw new TypeCheckException<TPk>(fragment, ErrorKind.ZeroThreshold);
+					}
+
+					if (self.Item1 > self.Item2.Length)
+					{
+						throw new TypeCheckException<TPk>(
+							fragment,
+							ErrorKind.OverThreshold,
+							new int[] {self.Item1, self.Item2.Length});
+					}
+					return prop.FromMulti(self.Item1, self.Item2.Length);
+				case Terminal<TPk>.After self:
+					if (self.Item == 0)
+					{
+						throw new TypeCheckException<TPk>(fragment, ErrorKind.ZeroTime);
+					}
+
+					return prop.FromAfter(self.Item);
+				case Terminal<TPk>.Older self:
+					if (self.Item == 0)
+					{
+						throw new TypeCheckException<TPk>(fragment, ErrorKind.ZeroTime);
+					}
+
+					return prop.FromOlder(self.Item);
+				case Terminal<TPk>.Sha256 self:
+					return prop.FromSha256();
+				case Terminal<TPk>.Hash256 self:
+					return prop.FromHash256();
+				case Terminal<TPk>.Ripemd160 self:
+					return prop.FromRipemd160();
+				case Terminal<TPk>.Alt self:
+					return GetChild(self.Item.Node, 0).CastAlt();
+				case Terminal<TPk>.Swap self:
+					return GetChild(self.Item.Node, 0).CastSwap();
+				case Terminal<TPk>.Check self:
+					return GetChild(self.Item.Node, 0).CastCheck();
+				case Terminal<TPk>.DupIf self:
+					return GetChild(self.Item.Node, 0).CastDupIf();
+				case Terminal<TPk>.Verify self:
+					return GetChild(self.Item.Node, 0).CastVerify();
+				case Terminal<TPk>.NonZero self:
+					return GetChild(self.Item.Node, 0).CastNonZero();
+				case Terminal<TPk>.AndB self:
+					var andBL = GetChild(self.Item1.Node, 0);
+					var andBR = GetChild(self.Item2.Node, 1);
+					return prop.AndB(andBL, andBR);
+				case Terminal<TPk>.AndV self:
+					var andVL = GetChild(self.Item1.Node, 0);
+					var andVR = GetChild(self.Item2.Node, 1);
+					return prop.AndV(andVL, andVR);
+				case Terminal<TPk>.OrB self:
+					var orBL = GetChild(self.Item1.Node, 0);
+					var orBR = GetChild(self.Item2.Node, 1);
+					return prop.OrB(orBL, orBR);
+				case Terminal<TPk>.OrD self:
+					var orDL = GetChild(self.Item1.Node, 0);
+					var orDR = GetChild(self.Item2.Node, 1);
+					return prop.OrD(orDL, orDR);
+				case Terminal<TPk>.OrC self:
+					var orCL = GetChild(self.Item1.Node, 0);
+					var orCR = GetChild(self.Item2.Node, 1);
+					return prop.OrC(orCL, orCR);
+				case Terminal<TPk>.OrI self:
+					var orIL = GetChild(self.Item1.Node, 0);
+					var orIR = GetChild(self.Item2.Node, 1);
+					return prop.OrC(orIL, orIR);
+				case Terminal<TPk>.AndOr self:
+					var a = GetChild(self.Item1.Node, 0);
+					var b = GetChild(self.Item2.Node, 1);
+					var c = GetChild(self.Item3.Node, 2);
+					return prop.AndOr(a, b, c);
+				case Terminal<TPk>.Thresh self:
+					if (self.Item1 == 0)
+					{
+						throw new TypeCheckException<TPk>(fragment, ErrorKind.ZeroThreshold);
+					}
+
+					if (self.Item1 > self.Item2.Length)
+					{
+						throw new TypeCheckException<TPk>(fragment, ErrorKind.OverThreshold);
+					}
+					return
+						prop.Threshold(self.Item1, self.Item2.Length, (n) =>
+							GetChild(self.Item2[n].Node, (int)n));
+			}
+			throw new Exception("Unreachable!");;
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
index f7b37a4a3c..42ad7b7328 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -1,14 +1,51 @@
-using System.Runtime.InteropServices;
+using System;
+using System.Diagnostics.Tracing;
+using NBitcoin.Scripting.Miniscript.Policy;
 
 namespace NBitcoin.Scripting.Miniscript.Types
 {
-	internal class Malleability : Property
+	/// <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;
+		}
+	}
+
+	internal class Malleability : IProperty<Malleability>
 	{
-		internal Dissat Dissat;
-		internal bool Safe;
-		internal bool NonMalleable;
+		internal readonly Dissat Dissat;
+		internal readonly bool Safe;
+		internal readonly bool NonMalleable;
 
-		private Malleability(Dissat dissat, bool safe, bool nonMalleable)
+		public Malleability(Dissat dissat, bool safe, bool nonMalleable)
 		{
 			Dissat = dissat;
 			Safe = safe;
@@ -16,36 +53,165 @@ private Malleability(Dissat dissat, bool safe, bool nonMalleable)
 		}
 
 		internal bool IsSubtype(Malleability other) =>
-			this.Dissat.IsSubtype((other.Dissat)) &&
-			(!(!(this.Safe) && other.Safe)) &&
-			(!(!(this.NonMalleable) && other.NonMalleable));
+			Dissat.IsSubType(other.Dissat) &&
+				other.Safe &&
+				!(!NonMalleable && other.NonMalleable);
 
-		internal static Malleability FromTrue() =>
-			new Malleability(Dissat.Unique, false, true);
+		public Malleability FromTrue() =>
+			new Malleability(Dissat.None, false, true);
 
-		internal static Malleability FromFalse() =>
-			new Malleability(Dissat.Unique,true, true);
-		internal static Malleability FromPk() =>
-			new Malleability(Dissat.Unique,true, true);
-	}
+		public Malleability FromFalse() =>
+			new Malleability(Dissat.None, true, true);
 
-	/// <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
-	{
-		None,
-		Unique,
-		Unknown
-	}
+		public Malleability FromPk() =>
+			new Malleability(Dissat.Unique, true, true);
 
-	internal static class DissatExtension
-	{
-		internal static bool IsSubtype(this Dissat self, Dissat other) =>
-			(self == other) || other == Dissat.Unknown;
+		public Malleability FromPkH() =>
+			new Malleability(Dissat.Unique, true, true);
+
+		public Malleability FromMulti(int k, int pkLength) =>
+			new Malleability(Dissat.Unique, true,true);
+
+		public Malleability FromAfter(uint time)
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability FromOlder(uint time)
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability FromHash() =>
+			new Malleability(Dissat.None, false, true);
+
+		public Malleability FromSha256()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability FromHash256()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability FromRipemd160()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability FromHash160()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability CastAlt() =>
+			this;
+
+		public Malleability CastSwap()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability CastCheck()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability CastDupIf()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability CastVerify()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability CastNonZero()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability CastZeroNotEqual()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability CastTrue()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability CastOrIFalse()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability CastUnLikely()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability CastLikely()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public Malleability AndB(Malleability left, Malleability right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Malleability AndV(Malleability left, Malleability right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Malleability AndN(Malleability left, Malleability right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Malleability OrB(Malleability left, Malleability right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Malleability OrD(Malleability left, Malleability right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Malleability OrC(Malleability left, Malleability right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Malleability OrI(Malleability left, Malleability right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Malleability AndOr(Malleability a, Malleability b, Malleability c)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Malleability Threshold(int k, int n, Func<uint, Malleability> subCk)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Malleability AndB()
+		{
+			throw new System.NotImplementedException();
+		}
+
+		public void SanityChecks()
+		{
+			throw new System.NotImplementedException();
+		}
 
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
new file mode 100644
index 0000000000..6132fa5a8d
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
@@ -0,0 +1,284 @@
+using System;
+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
+{
+	public class MiniscriptFragmentType : IProperty<MiniscriptFragmentType>
+	{
+		public readonly Correctness Correctness;
+
+		internal readonly Malleability Malleability;
+
+		private MiniscriptFragmentType(Correctness correctness, Malleability malleability)
+		{
+			Correctness = correctness;
+			Malleability = malleability;
+		}
+
+		public bool IsSubtype(MiniscriptFragmentType other) =>
+			this.Correctness.IsSubtype(other.Correctness) &&
+			this.Malleability.IsSubtype(other.Malleability);
+
+		public void SanityChecks()
+		{
+			Debug.Assert(!this.Correctness.DisSatisfiable || this.Malleability.Dissat != Dissat.None);
+			Debug.Assert(this.Malleability.Dissat == Dissat.None || this.Correctness.Base != Base.K);
+			Debug.Assert(this.Malleability.Safe || this.Correctness.Base != Base.K);
+			Debug.Assert(this.Malleability.NonMalleable || this.Correctness.Input != Input.Zero);
+		}
+
+		public MiniscriptFragmentType FromTrue()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(cor.FromTrue(), mal.FromTrue());
+		}
+
+		public MiniscriptFragmentType FromFalse()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(cor.FromFalse(), mal.FromFalse());
+		}
+
+		public MiniscriptFragmentType FromPk()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(cor.FromPk(), mal.FromPk());
+		}
+
+		public MiniscriptFragmentType FromPkH()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(cor.FromPkH(), mal.FromPkH());
+		}
+
+		public MiniscriptFragmentType FromMulti(int k, int pkLength)
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(cor.FromMulti(k, pkLength), mal.FromMulti(k, pkLength));
+		}
+
+		public MiniscriptFragmentType FromAfter(uint time)
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.FromAfter(time),
+				mal.FromAfter(time));
+		}
+
+		public MiniscriptFragmentType FromOlder(uint time)
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.FromOlder(time),
+				mal.FromOlder(time));
+		}
+
+		public MiniscriptFragmentType FromHash()
+		{
+
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.FromHash(),
+				mal.FromHash());
+		}
+
+		public MiniscriptFragmentType FromSha256()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.FromSha256(),
+				mal.FromSha256());
+		}
+
+		public MiniscriptFragmentType FromHash256()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.FromHash256(),
+				mal.FromHash256());
+		}
+
+		public MiniscriptFragmentType FromRipemd160()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.FromRipemd160(),
+				mal.FromRipemd160());
+		}
+
+		public MiniscriptFragmentType FromHash160()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.FromHash160(),
+				mal.FromHash160());
+		}
+
+		public MiniscriptFragmentType CastAlt()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.CastAlt(),
+				mal.CastAlt());
+		}
+
+		public MiniscriptFragmentType CastSwap()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.CastSwap(),
+				mal.CastSwap());
+		}
+
+		public MiniscriptFragmentType CastCheck()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.CastCheck(),
+				mal.CastCheck());
+		}
+
+		public MiniscriptFragmentType CastDupIf()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.CastDupIf(),
+				mal.CastDupIf());
+		}
+
+		public MiniscriptFragmentType CastVerify()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.CastVerify(),
+				mal.CastVerify());
+		}
+
+		public MiniscriptFragmentType CastNonZero()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.CastNonZero(),
+				mal.CastNonZero());
+		}
+
+		public MiniscriptFragmentType CastZeroNotEqual()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.CastZeroNotEqual(),
+				mal.CastZeroNotEqual());
+		}
+
+		public MiniscriptFragmentType CastTrue()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.CastTrue(),
+				mal.CastTrue());
+		}
+
+		public MiniscriptFragmentType CastOrIFalse()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.CastOrIFalse(),
+				mal.CastOrIFalse());
+		}
+
+		public MiniscriptFragmentType CastUnLikely()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.CastUnLikely(),
+				mal.CastUnLikely());
+		}
+
+		public MiniscriptFragmentType CastLikely()
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.CastLikely(),
+				mal.CastLikely());
+		}
+
+		public MiniscriptFragmentType AndB(MiniscriptFragmentType left, MiniscriptFragmentType right)
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.AndB(left.Correctness, right.Correctness),
+				mal.AndB(left.Malleability, right.Malleability));
+		}
+
+		public MiniscriptFragmentType AndV(MiniscriptFragmentType left, MiniscriptFragmentType right)
+		{
+			Correctness cor = default;
+			Malleability mal = default;
+			return new MiniscriptFragmentType(
+				cor.AndV(left.Correctness, right.Correctness),
+				mal.AndV(left.Malleability, right.Malleability));
+		}
+
+		public MiniscriptFragmentType AndN(MiniscriptFragmentType left, MiniscriptFragmentType right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public MiniscriptFragmentType OrB(MiniscriptFragmentType left, MiniscriptFragmentType right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public MiniscriptFragmentType OrD(MiniscriptFragmentType left, MiniscriptFragmentType right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public MiniscriptFragmentType OrC(MiniscriptFragmentType left, MiniscriptFragmentType right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public MiniscriptFragmentType OrI(MiniscriptFragmentType left, MiniscriptFragmentType right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public MiniscriptFragmentType AndOr(MiniscriptFragmentType a, MiniscriptFragmentType b, MiniscriptFragmentType c)
+		{
+			throw new NotImplementedException();
+		}
+
+		public MiniscriptFragmentType Threshold(int k, int n, Func<uint, MiniscriptFragmentType> subCk)
+		{
+			throw new NotImplementedException();
+		}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/Types.cs b/NBitcoin/Scripting/Miniscript/Types/Types.cs
index 7d7260ef32..6f7523b44f 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Types.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Types.cs
@@ -1,7 +1,3 @@
 namespace NBitcoin.Scripting.Miniscript.Types
 {
-	internal interface Property
-	{
-		void SanityChecks();
-	}
 }
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
+	}
+
+}

From c4a66cfc028a001c367928746e2532ec90a28699 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Thu, 31 Oct 2019 11:30:18 +0900
Subject: [PATCH 04/50] Update

---
 NBitcoin/PubKey.cs                            |  12 +-
 NBitcoin/Scripting/Miniscript/AstElem.cs      | 191 ++++----
 NBitcoin/Scripting/Miniscript/ILiftable.cs    |  60 +--
 NBitcoin/Scripting/Miniscript/Miniscript.cs   |  24 +-
 .../MiniscriptDSLParser.Terminal.cs           | 120 ++++-
 .../MiniscriptDSLParsers.ConcretePolicy.cs    | 178 ++++----
 .../Scripting/Miniscript/MiniscriptKey.cs     |  13 +-
 .../Miniscript/MiniscriptScriptParser.cs      |  49 +-
 .../Miniscript/Policy/AbstractPolicy.cs       |  90 ++--
 .../Scripting/Miniscript/Policy/Compiler.cs   | 419 ++++++++++++++++--
 .../Miniscript/Policy/ConcretePolicy.cs       |  94 ++--
 .../Scripting/Miniscript/Types/IProperty.cs   |  90 ++--
 .../Scripting/Miniscript/Types/Property.cs    |  30 ++
 NBitcoin/UInt2561.cs                          |  12 +-
 14 files changed, 953 insertions(+), 429 deletions(-)
 create mode 100644 NBitcoin/Scripting/Miniscript/Types/Property.cs

diff --git a/NBitcoin/PubKey.cs b/NBitcoin/PubKey.cs
index c6ce0dcd19..7ccb841e8f 100644
--- a/NBitcoin/PubKey.cs
+++ b/NBitcoin/PubKey.cs
@@ -31,7 +31,7 @@ public enum ScriptPubKeyType
 		/// </summary>
 		SegwitP2SH
 	}
-	public class PubKey : IBitcoinSerializable, IDestination, IComparable<PubKey>, IEquatable<PubKey>, IMiniscriptKey
+	public class PubKey : IBitcoinSerializable, IDestination, IComparable<PubKey>, IEquatable<PubKey>, IMiniscriptKey<uint160>
 	{
 		/// <summary>
 		/// Create a new Public key from string
@@ -68,6 +68,11 @@ public bool TryParse(string hex)
 			return true;
 		}
 
+		public bool Equals(IMiniscriptKey<uint160> other)
+		{
+			throw new NotImplementedException();
+		}
+
 		/// <summary>
 		/// Create a new Public key from byte array
 		/// </summary>
@@ -577,6 +582,11 @@ public BitcoinWitPubKeyAddress GetSegwitAddress(Network network)
 		#endregion
 
 		public IMiniscriptKeyHash MiniscriptKeyHash => Hash;
+		public uint160 ToPubKeyHash()
+		{
+			throw new NotImplementedException();
+		}
+
 		public PubKey ToPublicKey() => this;
 
 		public int SerializedLength() =>
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 1ee089b842..b5b77241b0 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -91,7 +91,9 @@ public bool Equals(NonTerm other)
 		#endregion
 	}
 
-	public partial class Terminal<TPk> : IEquatable<Terminal<TPk>> where TPk : IMiniscriptKey
+	public partial class Terminal<TPk, TPKh> : IEquatable<Terminal<TPk, TPKh>>
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 	{
 		# region Subtype definitions
 		internal static class Tags
@@ -127,179 +129,179 @@ internal static class Tags
 		internal int Tag;
 
 		private Terminal(int tag) => Tag = tag;
-		public static Terminal<TPk> True { get; } = new Terminal<TPk>(Tags.True);
-		public static Terminal<TPk> False { get; } = new Terminal<TPk>(Tags.False);
+		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>
+		internal class Pk : Terminal<TPk, TPKh>
 		{
 			readonly public TPk Item;
 			public Pk(TPk pk) : base(Tags.Pk) => Item = pk;
 		}
 
-		internal class PkH : Terminal<TPk>
+		internal class PkH : Terminal<TPk, TPKh>
 		{
-			readonly public IMiniscriptKeyHash Item;
-			public PkH(IMiniscriptKeyHash item) : base(Tags.PkH) => Item = item;
+			readonly public TPKh Item;
+			public PkH(TPKh item) : base(Tags.PkH) => Item = item;
 		}
 
-		internal class After : Terminal<TPk>
+		internal class After : Terminal<TPk, TPKh>
 		{
 			readonly public uint Item;
 			public After(uint item) : base(Tags.After) => Item = item;
 		}
 
-		internal class Older : Terminal<TPk>
+		internal class Older : Terminal<TPk, TPKh>
 		{
 			readonly public uint Item;
 			public Older(uint item) : base(Tags.Older) => Item = item;
 		}
 
-		internal class Sha256 : Terminal<TPk>
+		internal class Sha256 : Terminal<TPk, TPKh>
 		{
 			readonly public uint256 Item;
 			public Sha256(uint256 item) : base(Tags.Sha256) => Item = item;
 		}
-		internal class Hash256 : Terminal<TPk>
+		internal class Hash256 : Terminal<TPk, TPKh>
 		{
 			readonly public uint256 Item;
 			public Hash256(uint256 item) : base(Tags.Hash256) => Item = item;
 		}
 
-		internal class Ripemd160 : Terminal<TPk>
+		internal class Ripemd160 : Terminal<TPk, TPKh>
 		{
 			readonly public uint160 Item;
 			public Ripemd160(uint160 item) : base(Tags.Ripemd160) => Item = item;
 		}
 
-		internal class Hash160 : Terminal<TPk>
+		internal class Hash160 : Terminal<TPk, TPKh>
 		{
 			readonly public uint160 Item;
 			public Hash160(uint160 item) : base(Tags.Hash160) => Item = item;
 		}
 
-		internal class Alt : Terminal<TPk>
+		internal class Alt : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item;
-			public Alt(Miniscript<TPk> item) : base(Tags.Alt) => Item = item;
+			readonly public Miniscript<TPk, TPKh> Item;
+			public Alt(Miniscript<TPk, TPKh> item) : base(Tags.Alt) => Item = item;
 		}
 
-		internal class Swap : Terminal<TPk>
+		internal class Swap : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item;
-			public Swap(Miniscript<TPk> item): base(Tags.Swap) => Item = item;
+			readonly public Miniscript<TPk, TPKh> Item;
+			public Swap(Miniscript<TPk, TPKh> item): base(Tags.Swap) => Item = item;
 		}
 
-		internal class Check : Terminal<TPk>
+		internal class Check : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item;
-			public Check(Miniscript<TPk> item): base(Tags.Check) => Item = item;
+			readonly public Miniscript<TPk, TPKh> Item;
+			public Check(Miniscript<TPk, TPKh> item): base(Tags.Check) => Item = item;
 		}
-		internal class DupIf : Terminal<TPk>
+		internal class DupIf : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item;
-			public DupIf (Miniscript<TPk> item): base(Tags.DupIf ) => Item = item;
+			readonly public Miniscript<TPk, TPKh> Item;
+			public DupIf (Miniscript<TPk, TPKh> item): base(Tags.DupIf ) => Item = item;
 		}
-		internal class Verify : Terminal<TPk>
+		internal class Verify : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item;
-			public Verify(Miniscript<TPk> item): base(Tags.Verify) => Item = item;
+			readonly public Miniscript<TPk, TPKh> Item;
+			public Verify(Miniscript<TPk, TPKh> item): base(Tags.Verify) => Item = item;
 		}
-		internal class NonZero : Terminal<TPk>
+		internal class NonZero : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item;
-			public NonZero(Miniscript<TPk> item): base(Tags.NonZero) => Item = item;
+			readonly public Miniscript<TPk, TPKh> Item;
+			public NonZero(Miniscript<TPk, TPKh> item): base(Tags.NonZero) => Item = item;
 		}
-		internal class ZeroNotEqual : Terminal<TPk>
+		internal class ZeroNotEqual : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item;
-			public ZeroNotEqual(Miniscript<TPk> item): base(Tags.ZeroNotEqual) => Item = item;
+			readonly public Miniscript<TPk, TPKh> Item;
+			public ZeroNotEqual(Miniscript<TPk, TPKh> item): base(Tags.ZeroNotEqual) => Item = item;
 		}
-		internal class AndV : Terminal<TPk>
+		internal class AndV : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item1;
-			readonly public Miniscript<TPk> Item2;
-			public AndV(Miniscript<TPk> item1,Miniscript<TPk> item2): base(Tags.AndV)
+			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>
+		internal class AndB : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item1;
-			readonly public Miniscript<TPk> Item2;
-			public AndB(Miniscript<TPk> item, Miniscript<TPk> item2): base(Tags.AndB)
+			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>
+		internal class AndOr : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item1;
-			readonly public Miniscript<TPk> Item2;
-			readonly public Miniscript<TPk> Item3;
+			readonly public Miniscript<TPk, TPKh> Item1;
+			readonly public Miniscript<TPk, TPKh> Item2;
+			readonly public Miniscript<TPk, TPKh> Item3;
 
-			public AndOr(Miniscript<TPk> item1, Miniscript<TPk> item2, Miniscript<TPk> item3) : base(Tags.AndOr)
+			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>
+		internal class OrB : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item1;
-			readonly public Miniscript<TPk> Item2;
-			public OrB(Miniscript<TPk> item1, Miniscript<TPk> item2): base(Tags.OrB)
+			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>
+		internal class OrD : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item1;
-			readonly public Miniscript<TPk> Item2;
-			public OrD(Miniscript<TPk> item1, Miniscript<TPk> item2): base(Tags.OrD)
+			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>
+		internal class OrC : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item1;
-			readonly public Miniscript<TPk> Item2;
-			public OrC(Miniscript<TPk> item1, Miniscript<TPk> item2): base(Tags.OrC)
+			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>
+		internal class OrI : Terminal<TPk, TPKh>
 		{
-			readonly public Miniscript<TPk> Item1;
-			readonly public Miniscript<TPk> Item2;
-			public OrI(Miniscript<TPk> item1, Miniscript<TPk> item2): base(Tags.OrI)
+			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>
+		internal class Thresh : Terminal<TPk, TPKh>
 		{
 			readonly public uint Item1;
-			readonly public Miniscript<TPk>[] Item2;
-			public Thresh(uint item1, Miniscript<TPk>[] item2): base(Tags.Thresh)
+			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>
+		internal class ThreshM : Terminal<TPk, TPKh>
 		{
 			readonly public uint Item1;
 			readonly public TPk[] Item2;
@@ -310,54 +312,55 @@ public ThreshM(uint item1, TPk[] item2): base(Tags.ThreshM)
 			}
 		}
 
-		public static Terminal<TPk> NewTrue() => Terminal<TPk>.True;
-		public static Terminal<TPk> NewFalse() => Terminal<TPk>.False;
-		public static Terminal<TPk> NewPk(TPk item) => new Pk(item);
-		public static Terminal<TPk> NewPkH(IMiniscriptKeyHash item) => new PkH(item);
-		public static Terminal<TPk> NewAfter(uint item) => new After(item);
-		public static Terminal<TPk> NewOlder(uint item) => new Older(item);
-		public static Terminal<TPk> NewSha256(uint256 item)
+		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) => 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> NewHash256(uint256 item)
+		public static Terminal<TPk, TPKh> NewHash256(uint256 item)
 			=> new Hash256(item);
-		public static Terminal<TPk> NewRipemd160(uint160 item)
+		public static Terminal<TPk, TPKh> NewRipemd160(uint160 item)
 			=> new Ripemd160(item);
-		public static Terminal<TPk> NewHash160(uint160 item)
+		public static Terminal<TPk, TPKh> NewHash160(uint160 item)
 			=> new Hash160(item);
-		public static Terminal<TPk> NewAlt(Miniscript<TPk> item) => new Terminal<TPk>.Alt(item);
-		public static Terminal<TPk> NewSwap(Miniscript<TPk> item) => new Terminal<TPk>.Swap(item);
-		public static Terminal<TPk> NewCheck(Miniscript<TPk> item) => new Terminal<TPk>.Check(item);
-		public static Terminal<TPk> NewDupIf(Miniscript<TPk> item) => new DupIf(item);
-		public static Terminal<TPk> NewVerify(Miniscript<TPk> item) => new Verify(item);
-		public static Terminal<TPk> NewNonZero(Miniscript<TPk> item) => new NonZero(item);
-
-		public static Terminal<TPk> NewAndV(Miniscript<TPk> item1, Miniscript<TPk> item2)
+		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) => new Terminal<TPk, TPKh>.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> NewAndB(Miniscript<TPk> item1, Miniscript<TPk> item2)
+		public static Terminal<TPk, TPKh> NewAndB(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2)
 			=> new AndB(item1, item2);
 
-		public static Terminal<TPk> NewAndOr(Miniscript<TPk> item1, Miniscript<TPk> item2, Miniscript<TPk> item3)
+		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> NewOrB(Miniscript<TPk> item1, Miniscript<TPk> item2)
+		public static Terminal<TPk, TPKh> NewOrB(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2)
 			=> new OrB(item1, item2);
 
-		public static Terminal<TPk> NewOrD(Miniscript<TPk> item1, Miniscript<TPk> item2)
+		public static Terminal<TPk, TPKh> NewOrD(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2)
 			=> new OrD(item1, item2);
-		public static Terminal<TPk> NewOrC(Miniscript<TPk> item1, Miniscript<TPk> item2)
+		public static Terminal<TPk, TPKh> NewOrC(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2)
 			=> new OrC(item1, item2);
-		public static Terminal<TPk> NewOrI(Miniscript<TPk> item1, Miniscript<TPk> item2)
+		public static Terminal<TPk, TPKh> NewOrI(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2)
 			=> new OrI(item1, item2);
 
-		public static Terminal<TPk> NewThresh(uint item1, IEnumerable<Miniscript<TPk>> item2)
+		public static Terminal<TPk, TPKh> NewThresh(uint item1, IEnumerable<Miniscript<TPk, TPKh>> item2)
 			=> new Thresh(item1, item2.ToArray());
-		public static Terminal<TPk> NewThreshM(uint item1, IEnumerable<TPk> item2)
+		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> other)
+		public bool Equals(Terminal<TPk, TPKh> other)
 		{
 			if (other == null)
 				return false;
diff --git a/NBitcoin/Scripting/Miniscript/ILiftable.cs b/NBitcoin/Scripting/Miniscript/ILiftable.cs
index 94596115dd..9ec63ac4c1 100644
--- a/NBitcoin/Scripting/Miniscript/ILiftable.cs
+++ b/NBitcoin/Scripting/Miniscript/ILiftable.cs
@@ -5,37 +5,43 @@
 
 namespace NBitcoin.Scripting.Miniscript
 {
-	public interface ILiftable<TPk> where TPk : IMiniscriptKey
+	public interface ILiftable<TPk, TPKh>
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 	{
-		AbstractPolicy<TPk> Lift();
+		AbstractPolicy<TPk, TPKh> Lift();
 	}
 
-	public partial class Miniscript<TPk> : ILiftable<TPk> where TPk : IMiniscriptKey
+	public partial class Miniscript<TPk, TPKh> : ILiftable<TPk, TPKh>
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 	{
-		public AbstractPolicy<TPk> Lift() =>
+		public AbstractPolicy<TPk, TPKh> Lift() =>
 			this.Node.Lift();
 	}
 
-	public partial class Terminal<TPk> : ILiftable<TPk> where TPk : IMiniscriptKey
+	public partial class Terminal<TPk, TPKh>
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 	{
-		public AbstractPolicy<TPk> Lift()
+		public AbstractPolicy<TPk, TPKh> Lift()
 		{
 			switch (this.Tag)
 			{
-				case Tags.True: return AbstractPolicy<TPk>.Trivial;
-				case Tags.False: return AbstractPolicy<TPk>.UnSatisfiable;
+				case Tags.True: return AbstractPolicy<TPk, TPKh>.Trivial;
+				case Tags.False: return AbstractPolicy<TPk, TPKh>.UnSatisfiable;
 			}
 
 			switch (this)
 			{
-				case Pk self: return AbstractPolicy<TPk>.NewKeyHash(self.Item.MiniscriptKeyHash);
-				case PkH self: return AbstractPolicy<TPk>.NewKeyHash(self.Item);
-				case After self: return AbstractPolicy<TPk>.NewAfter(self.Item);
-				case Older self: return AbstractPolicy<TPk>.NewOlder(self.Item);
-				case Sha256 self: return AbstractPolicy<TPk>.NewSha256(self.Item);
-				case Hash256 self: return AbstractPolicy<TPk>.NewHash256(self.Item);
-				case Ripemd160 self: return AbstractPolicy<TPk>.NewRipemd160(self.Item);
-				case Hash160 self: return AbstractPolicy<TPk>.NewHash160(self.Item);
+				case Pk self: return AbstractPolicy<TPk, TPKh>.NewKeyHash(self.Item.ToPubKeyHash());
+				case PkH self: return AbstractPolicy<TPk, TPKh>.NewKeyHash(self.Item);
+				case After self: return AbstractPolicy<TPk, TPKh>.NewAfter(self.Item);
+				case Older self: return AbstractPolicy<TPk, TPKh>.NewOlder(self.Item);
+				case Sha256 self: return AbstractPolicy<TPk, TPKh>.NewSha256(self.Item);
+				case Hash256 self: return AbstractPolicy<TPk, TPKh>.NewHash256(self.Item);
+				case Ripemd160 self: return AbstractPolicy<TPk, TPKh>.NewRipemd160(self.Item);
+				case Hash160 self: return AbstractPolicy<TPk, TPKh>.NewHash160(self.Item);
 				case Alt self: return self.Item.Node.Lift();
 				case Check self: return self.Item.Node.Lift();
 				case DupIf self: return self.Item.Node.Lift();
@@ -43,27 +49,27 @@ public AbstractPolicy<TPk> Lift()
 				case NonZero self: return self.Item.Node.Lift();
 				case ZeroNotEqual self: return self.Item.Node.Lift();
 				case AndV self:
-					return AbstractPolicy<TPk>.NewAnd(new List<AbstractPolicy<TPk>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift()});
+					return AbstractPolicy<TPk, TPKh>.NewAnd(new List<AbstractPolicy<TPk, TPKh>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift()});
 				case AndB self:
-					return AbstractPolicy<TPk>.NewAnd(new List<AbstractPolicy<TPk>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift()});
+					return AbstractPolicy<TPk, TPKh>.NewAnd(new List<AbstractPolicy<TPk, TPKh>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift()});
 				case AndOr self:
-					var inner = AbstractPolicy<TPk>.NewAnd(new List<AbstractPolicy<TPk>>() {self.Item1.Node.Lift(), self.Item3.Node.Lift()});
-					return AbstractPolicy<TPk>.NewOr(new List<AbstractPolicy<TPk>>() {inner, self.Item2.Node.Lift()});
+					var inner = AbstractPolicy<TPk, TPKh>.NewAnd(new List<AbstractPolicy<TPk, TPKh>>() {self.Item1.Node.Lift(), self.Item3.Node.Lift()});
+					return AbstractPolicy<TPk, TPKh>.NewOr(new List<AbstractPolicy<TPk, TPKh>>() {inner, self.Item2.Node.Lift()});
 				case OrB self:
-					return AbstractPolicy<TPk>.NewOr(new List<AbstractPolicy<TPk>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() });
+					return AbstractPolicy<TPk, TPKh>.NewOr(new List<AbstractPolicy<TPk, TPKh>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() });
 				case OrD self:
-					return AbstractPolicy<TPk>.NewOr(new List<AbstractPolicy<TPk>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() });
+					return AbstractPolicy<TPk, TPKh>.NewOr(new List<AbstractPolicy<TPk, TPKh>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() });
 				case OrC self:
-					return AbstractPolicy<TPk>.NewOr(new List<AbstractPolicy<TPk>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() });
+					return AbstractPolicy<TPk, TPKh>.NewOr(new List<AbstractPolicy<TPk, TPKh>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() });
 				case OrI self:
-					return AbstractPolicy<TPk>.NewOr(new List<AbstractPolicy<TPk>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() });
+					return AbstractPolicy<TPk, TPKh>.NewOr(new List<AbstractPolicy<TPk, TPKh>>() { self.Item1.Node.Lift(), self.Item2.Node.Lift() });
 				case Thresh self:
-					return AbstractPolicy<TPk>.NewThreshold(self.Item1, self.Item2.Select(sub => sub.Node.Lift()).ToList());
+					return AbstractPolicy<TPk, TPKh>.NewThreshold(self.Item1, self.Item2.Select(sub => sub.Node.Lift()).ToList());
 				case ThreshM self:
 					return
-						AbstractPolicy<TPk>.NewThreshold(
+						AbstractPolicy<TPk, TPKh>.NewThreshold(
 							self.Item1,
-							self.Item2.Select(sub => AbstractPolicy<TPk>.NewKeyHash(sub.Item.MiniscriptKeyHash)).ToList()
+							self.Item2.Select(sub => AbstractPolicy<TPk, TPKh>.NewKeyHash(sub.ToPubKeyHash())).ToList()
 						);
 			}
 
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index 0dd1853254..cb23dbbf06 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -3,9 +3,11 @@
 
 namespace NBitcoin.Scripting.Miniscript
 {
-	public partial class Miniscript<TPk> where TPk : IMiniscriptKey
+	public partial class Miniscript<TPk, TPKh>
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 	{
-		internal readonly Terminal<TPk> Node;
+		internal readonly Terminal<TPk, TPKh> Node;
 		public readonly MiniscriptFragmentType Type;
 
 		/// <summary>
@@ -14,35 +16,39 @@ public partial class Miniscript<TPk> where TPk : IMiniscriptKey
 		/// <returns></returns>
 		internal readonly ExtData Ext;
 
-		internal Miniscript(MiniscriptFragmentType type, Terminal<TPk> node, ExtData ext)
+		internal Miniscript(MiniscriptFragmentType type, Terminal<TPk, TPKh> node, ExtData ext)
 		{
 			Type = type;
 			Node = node;
 			Ext = ext;
 		}
 
-		public static Miniscript<TPk> FromAst(Terminal<TPk> t)
+		public static Miniscript<TPk, TPKh> FromAst(Terminal<TPk, TPKh> t)
 		{
 			MiniscriptFragmentType ty = default;
 			ExtData ext = default;
 
 			return
-				new Miniscript<TPk>(
+				new Miniscript<TPk, TPKh>(
 					ty.TypeCheck(t, (_) => null),
 					t,
 					ext.TypeCheck(t, (_) => null)
 				);
 		}
 
-		public static Miniscript<TPk> Parse(string str)
+		public static Miniscript<TPk, TPKh> Parse(string str)
 		{
-			var inner = MiniscriptDSLParser.ParseDSL<TPk>(str);
+			var inner = MiniscriptDSLParser<TPk, TPKh>.ParseTerminal(str);
 			MiniscriptFragmentType ty = default;
 			ExtData ext = default;
-			new Miniscript<TPk>(ty.TypeCheck<MiniscriptFragmentType, TPk>(inner));
+			return new Miniscript<TPk, TPKh>(
+				ty.TypeCheck(inner),
+				inner,
+				ext.TypeCheck(inner)
+				);
 		}
 
-		public Script Encode() =>
+		public Script ToScript() =>
 			Node.ToScript();
 
 	}
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
index 945a9ffc53..3be0196317 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
@@ -1,7 +1,125 @@
+using System;
+using System.Linq;
+using NBitcoin.Scripting.Miniscript.Policy;
+using NBitcoin.Scripting.Parser;
+
 namespace NBitcoin.Scripting.Miniscript
 {
-	internal static partial class MiniscriptDSLParser
+	internal static partial class MiniscriptDSLParser<TPk, TPKh>
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 	{
+		# region Leaf
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalPk
+			=
+			from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
+			select Terminal<TPk, TPKh>.NewPk(pk);
+
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalPkH
+			=
+			from pkH in ExprP("pk_h").Then(TryParseMiniscriptKeyHash)
+			select Terminal<TPk, TPKh>.NewPkH(pkH);
+
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalTrue =
+			from _t in Parse.Char('0').Token()
+			select Terminal<TPk, TPKh>.NewTrue();
+
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalAfter =
+			from t in ExprP("after").Then(s => TryConvert(s, UInt32.Parse))
+			select Terminal<TPk, TPKh>.NewAfter(t);
+
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalOlder =
+			from t in ExprP("older").Then(s => TryConvert(s, UInt32.Parse))
+			select Terminal<TPk, TPKh>.NewOlder(t);
+
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalSha256 =
+			from t in ExprP("sha256").Then(s => TryConvert(s, uint256.Parse))
+			select Terminal<TPk, TPKh>.NewSha256(t);
+
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalHash256 =
+			from t in ExprP("hash256").Then(s => TryConvert(s, uint256.Parse))
+			select Terminal<TPk, TPKh>.NewHash256(t);
+
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalRipemd160 =
+			from t in ExprP("ripemd160").Then(s => TryConvert(s, uint160.Parse))
+			select Terminal<TPk, TPKh>.NewRipemd160(t);
+
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalHash160 =
+			from t in ExprP("hash160").Then(s => TryConvert(s, uint160.Parse))
+			select Terminal<TPk, TPKh>.NewHash160(t);
+
+		#endregion
+
+		private static Parser<char, Terminal<TPk, TPKh>> PWrapper(char identifier,
+			Func<Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> construct)
+			=>
+				from _t in Parse.Char(identifier).Then(_ => Parse.Char(':'))
+				from inner in TerminalDSLParser
+					.Except(PWrapper(identifier, construct)) // should not have same wrapper twice
+				select construct(Miniscript<TPk, TPKh>.FromAst(inner));
+
+		private static Parser<char, Terminal<TPk, TPKh>> PBinary(
+			string identifier,
+			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> constructor
+		) =>
+			from s in PSubExprs(identifier, TerminalDSLParser)
+			where s.Count() == 2
+			select constructor(Miniscript<TPk, TPKh>.FromAst(s.ElementAt(0)),
+				Miniscript<TPk, TPKh>.FromAst(s.ElementAt(1)));
+
+		private static Parser<char, Terminal<TPk, TPKh>> PTernary(
+			string identifier,
+			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> constructor
+		) =>
+			from s in PSubExprs(identifier, TerminalDSLParser)
+			where s.Count() == 3
+			select constructor(
+				Miniscript<TPk, TPKh>.FromAst(s.ElementAt(0)),
+				Miniscript<TPk, TPKh>.FromAst(s.ElementAt(1)),
+				Miniscript<TPk, TPKh>.FromAst(s.ElementAt(2)));
+
+		private static Parser<char, Terminal<TPk, TPKh>> PTerminalThresh =
+			PThresh(
+				"thresh",
+				Terminal<TPk, TPKh>.NewThresh,
+				TerminalDSLParser.Select(t => Miniscript<TPk, TPKh>.FromAst(t)));
+
+		private static Parser<char, Terminal<TPk, TPKh>> PTerminalThreshM =
+			PThresh("thresh_m", Terminal<TPk, TPKh>.NewThreshM,
+			(from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
+			select pk));
+
+		private static readonly Parser<char, Terminal<TPk, TPKh>> TerminalDSLParser =
+			// ------ leafs ------
+			PTerminalPk
+				.Or(PTerminalPkH)
+				.Or(PTerminalAfter)
+				.Or(PTerminalOlder)
+				.Or(PTerminalSha256)
+				.Or(PTerminalHash256)
+				.Or(PTerminalRipemd160)
+				.Or(PTerminalHash160)
+				// ------- wrappers --------
+				.Or(PWrapper('a', Terminal<TPk, TPKh>.NewAlt))
+				.Or(PWrapper('s', Terminal<TPk, TPKh>.NewSwap))
+				.Or(PWrapper('c', Terminal<TPk, TPKh>.NewCheck))
+				.Or(PWrapper('d', Terminal<TPk, TPKh>.NewDupIf))
+				.Or(PWrapper('v', Terminal<TPk, TPKh>.NewVerify))
+				.Or(PWrapper('j', Terminal<TPk, TPKh>.NewZeroNotEqual))
+				// ------- Conjunctions -----
+				.Or(PBinary("and_v", Terminal<TPk, TPKh>.NewAndV))
+				.Or(PBinary("and_b", Terminal<TPk, TPKh>.NewAndB))
+				.Or(PTernary("and_or", Terminal<TPk, TPKh>.NewAndOr))
+				// ------- Disjunctions  -----
+				.Or(PBinary("or_b", Terminal<TPk, TPKh>.NewOrB))
+				.Or(PBinary("or_d", Terminal<TPk, TPKh>.NewOrD))
+				.Or(PBinary("or_c", Terminal<TPk, TPKh>.NewOrC))
+				.Or(PBinary("or_i", Terminal<TPk, TPKh>.NewOrI))
+				// ------- Thresholds ------
+				.Or(PTerminalThresh)
+				.Or(PTerminalThreshM);
 
+		public static Terminal<TPk, TPKh> ParseTerminal(string input)
+			=> TerminalDSLParser.Parse(input);
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
index 03ae113b7e..02acb359b0 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
@@ -8,9 +8,11 @@
 using NBitcoin.Scripting.Miniscript;
 using NBitcoin.Scripting.Miniscript.Policy;
 
-namespace NBitcoin.Scripting
+namespace NBitcoin.Scripting.Miniscript
 {
-	internal static partial class MiniscriptDSLParser
+	internal static partial class MiniscriptDSLParser<TPk, TPKh>
+			where TPk : IMiniscriptKey<TPKh>
+			where TPKh : IMiniscriptKeyHash
 	{
 		internal static readonly Parser<char, string> SurroundedByBrackets  =
 				from leftB in Parse.Char('(').Token()
@@ -79,16 +81,24 @@ internal static Parser<char, T> TryConvert<T>(string str, Func<string, T> conver
 			};
 		}
 
-		internal static Parser<char, TPk> TryParseMiniscriptKey<TPk>(string str)
-			where TPk : IMiniscriptKey
+		internal static Parser<char, TPk> TryParseMiniscriptKey(string str)
 			=> i =>
 			{
 				TPk t = default;
 				if (!t.TryParse(str))
-					return ParserResult<char, TPk>.Failure(i, $"Failed to parse MiniscriptKey {i}");
+					return ParserResult<char, TPk>.Failure(i, $"Failed to parse MiniscriptKey {str}");
 				return ParserResult<char, TPk>.Success(i, t);
 			};
 
+		internal static Parser<char, TPKh> TryParseMiniscriptKeyHash(string str)
+			=> i =>
+			{
+				TPKh t = default;
+				if (!t.TryParse(str))
+					return ParserResult<char, TPKh>.Failure(i, "");
+				return ParserResult<char, TPKh>.Success(i, t);
+			};
+
 		internal static Parser<char, string> ExprP(string name)
 			=>
 			from identifier in Parse.String(name)
@@ -100,117 +110,109 @@ private static Parser<char, string[]> ExprPMany(string name)
 			from x in ExprP(name)
 			select SafeSplit(x);
 
-		private static Parser<char, ConcretePolicy<TPk>> PPubKeyExpr<TPk>()
-			where TPk : IMiniscriptKey
-			=>
-			from pk in ExprP("pk").Then(s => TryParseMiniscriptKey<TPk>(s))
-			select ConcretePolicy<TPk>.NewKey(pk);
+		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PPubKeyExpr
+			=
+			from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
+			select ConcretePolicy<TPk, TPKh>.NewKey(pk);
 
-		private static Parser<char, ConcretePolicy<TPk>> PSha256Expr<TPk>()
-			where TPk : IMiniscriptKey
-			=>
+		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PSha256Expr
+			=
 			from hash in ExprP("sha256").Then(s => TryConvert(s, uint256.Parse))
-			select ConcretePolicy<TPk>.NewSha256(hash);
+			select ConcretePolicy<TPk, TPKh>.NewSha256(hash);
 
-		private static Parser<char, ConcretePolicy<TPk>> PHash256Expr<TPk>()
-			where TPk : IMiniscriptKey
-			=>
+		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PHash256Expr
+			=
 			from hash in ExprP("hash256").Then(s => TryConvert(s, uint256.Parse))
-			select ConcretePolicy<TPk>.NewHash256(hash);
+			select ConcretePolicy<TPk, TPKh>.NewHash256(hash);
 
-		private static Parser<char, ConcretePolicy<TPk>> PRipemd160Expr<TPk>()
-			where TPk : IMiniscriptKey
-			=>
+		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PRipemd160Expr
+			=
 			from hash in ExprP("ripemd160").Then(s => TryConvert(s, uint160.Parse))
-			select ConcretePolicy<TPk>.NewRipemd160(hash);
+			select ConcretePolicy<TPk, TPKh>.NewRipemd160(hash);
 
-		private static Parser<char, ConcretePolicy<TPk>> PHash160Expr<TPk>()
-			where TPk : IMiniscriptKey
-			=>
+		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PHash160Expr
+			=
 			from hash in ExprP("hash160").Then(s => TryConvert(s, uint160.Parse))
-			select ConcretePolicy<TPk>.NewHash160(hash);
+			select ConcretePolicy<TPk, TPKh>.NewHash160(hash);
 
-		private static Parser<char, ConcretePolicy<TPk>> PAfterExpr<TPk>()
-			where TPk : IMiniscriptKey
-			=>
+		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PAfterExpr
+			=
 			from t in ExprP("after").Then(s => TryConvert(s, UInt32.Parse))
-			select ConcretePolicy<TPk>.NewAfter(t);
+			select ConcretePolicy<TPk, TPKh>.NewAfter(t);
 
-		private static Parser<char, ConcretePolicy<TPk>> POlderExpr<TPk>()
-			where TPk : IMiniscriptKey
-			=>
+		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> POlderExpr
+			=
 			from t in ExprP("older").Then(s => TryConvert(s, UInt32.Parse))
-			select ConcretePolicy<TPk>.NewOlder(t);
+			select ConcretePolicy<TPk, TPKh>.NewOlder(t);
 
-		private static Parser<char, IEnumerable<TSub>> PSubExprs<TSub>(string name, Func<Parser<char, TSub>> subP) =>
+		private static Parser<char, IEnumerable<TSub>> PSubExprs<TSub>(string name, Parser<char, TSub> subP) =>
 			from _n in Parse.String(name)
 			from _left in Parse.Char('(')
 			from x in Parse
-				.Ref(subP)
+				.Ref(() => subP)
 				.DelimitedBy(Parse.Char(',').Token()).Token()
 			from _right in Parse.Char(')')
 			select x;
 
-		private static Parser<char, ConcretePolicy<TPk>> PAndExpr<TPk>()
-			where TPk : IMiniscriptKey
-			=>
-			from x in PSubExprs("and", DSLParser<TPk>)
-			select ConcretePolicy<TPk>.NewAnd(x);
+		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PAndExpr
+			=
+			from x in PSubExprs("and", DSLParser)
+			select ConcretePolicy<TPk, TPKh>.NewAnd(x);
 
-		private static Parser<char, Tuple<uint, ConcretePolicy<TPk>>> POrWithProb<TPk>()
-			where TPk : IMiniscriptKey
-			=>
+		private static readonly Parser<char, Tuple<uint, ConcretePolicy<TPk, TPKh>>> POrWithProb
+			=
 			from x in Parse.Digit.AtLeastOnce().Text()
 				.Then(digitStr => TryConvert(digitStr, UInt32.Parse))
 			from _a in Parse.Char('@')
-			from sub in Parse.Ref(DSLParser<TPk>)
+			from sub in Parse.Ref(() => DSLParser)
 			select Tuple.Create(x, sub);
 
-		private static Parser<char, Tuple<uint, ConcretePolicy<TPk>>> POrWithoutProb<TPk>()
-			where TPk : IMiniscriptKey
-			=>
-			from sub in Parse.Ref(DSLParser<TPk>)
+		private static readonly Parser<char, Tuple<uint, ConcretePolicy<TPk, TPKh>>> POrWithoutProb
+			=
+			from sub in Parse.Ref(() => DSLParser)
 			select Tuple.Create(1U, sub);
 
-		private static Parser<char, ConcretePolicy<TPk>> POrExpr<TPk>()
-			where TPk : IMiniscriptKey
-			=>
+		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> POrExpr
+			=
 			from x in
-				PSubExprs("or", POrWithProb<TPk>)
-				.Or(PSubExprs("or", POrWithoutProb<TPk>))
-			select ConcretePolicy<TPk>.NewOr(x);
-
-		internal static Parser<char, ConcretePolicy<TPk>> PThresholdExpr<TPk>()
-			where TPk : IMiniscriptKey
-			=>
-				from _n in Parse.String("thres")
-				from _left in Parse.Char('(')
-				from numStr in Parse.Digit.AtLeastOnce().Text()
-				from _sep in Parse.Char(',')
-				from num in TryConvert(numStr, UInt32.Parse)
-				from x in Parse
-					.Ref(DSLParser<TPk>)
-					.DelimitedBy(Parse.Char(',').Token()).Token()
-				from _right in Parse.Char(')')
-				where num <= x.Count()
-				select ConcretePolicy<TPk>.NewThreshold(num, x.ToArray());
-
-		internal static Parser<char, ConcretePolicy<TPk>> DSLParser<TPk>()
-				where TPk : IMiniscriptKey
-				=>
-				(PPubKeyExpr<TPk>()
-					.Or(PAfterExpr<TPk>())
-					.Or(POlderExpr<TPk>())
-					.Or(PSha256Expr<TPk>())
-					.Or(PHash256Expr<TPk>())
-					.Or(PRipemd160Expr<TPk>())
-					.Or(PHash160Expr<TPk>())
-					.Or(PAndExpr<TPk>())
-					.Or(POrExpr<TPk>())
-					.Or(PThresholdExpr<TPk>())).Token();
-
-		public static ConcretePolicy<TPk> ParseDSL<TPk>(string input)
-			where TPk : IMiniscriptKey
-			=> DSLParser<TPk>().Parse(input);
+				PSubExprs("or", POrWithProb)
+				.Or(PSubExprs("or", POrWithoutProb))
+			select ConcretePolicy<TPk, TPKh>.NewOr(x);
+
+		private static Parser<char, T> PThresh<T, TIn>(
+			string identifier,
+			Func<uint, IEnumerable<TIn>, T> constructor,
+			Parser<char, TIn> subP
+			) =>
+			from _n in Parse.String(identifier)
+			from _left in Parse.Char('(')
+			from numStr in Parse.Digit.AtLeastOnce().Text()
+			from _sep in Parse.Char(',')
+			from num in TryConvert(numStr, UInt32.Parse)
+			from x in Parse
+				.Ref(() => subP)
+				.DelimitedBy(Parse.Char(',').Token()).Token()
+			from _right in Parse.Char(')')
+			where num <= x.Count()
+			select constructor(num, x);
+
+		internal static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PThresholdExpr =
+			PThresh("thresh", ConcretePolicy<TPk, TPKh>.NewThreshold, DSLParser);
+
+		internal static readonly Parser<char, ConcretePolicy<TPk, TPKh>> DSLParser
+			=
+			(PPubKeyExpr
+				.Or(PAfterExpr)
+				.Or(POlderExpr)
+				.Or(PSha256Expr)
+				.Or(PHash256Expr)
+				.Or(PRipemd160Expr)
+				.Or(PHash160Expr)
+				.Or(PAndExpr)
+				.Or(POrExpr)
+				.Or(PThresholdExpr)).Token();
+
+		public static ConcretePolicy<TPk, TPKh> ParseConcretePolicy(string input)
+			=> DSLParser.Parse(input);
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
index f2e4259cbc..d8ce0f1eb9 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
@@ -5,14 +5,19 @@ namespace NBitcoin.Scripting.Miniscript
 	public interface IMiniscriptKeyHash
 	{
 		uint160 ToHash160();
+		string ToHex();
+		bool TryParse(string str);
 	}
 
 	/// <summary>
-	/// Interface to abstract PubKey in Miniscript
+	/// 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
+	public interface IMiniscriptKey<TPKh> where TPKh : IMiniscriptKeyHash
 	{
-		IMiniscriptKeyHash MiniscriptKeyHash { get; }
+		TPKh ToPubKeyHash();
 
 		/// <summary>
 		/// Converts an object to public key
@@ -31,7 +36,7 @@ public interface IMiniscriptKey
 
 		bool TryParse(string str);
 
-		bool Equals(IMiniscriptKey other);
+		bool Equals(IMiniscriptKey<TPKh> other);
 	}
 
 }
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs b/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
index 907b31d530..a87d2f641a 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
@@ -1,12 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using System.Runtime.InteropServices.ComTypes;
 using NBitcoin.Scripting.Miniscript.Types;
-using NBitcoin.Scripting.Parser;
-
-using P = NBitcoin.Scripting.Parser.Parser<NBitcoin.Scripting.Miniscript.ScriptToken, NBitcoin.Scripting.Miniscript.Miniscript>;
 
 namespace NBitcoin.Scripting.Miniscript
 {
@@ -396,46 +390,42 @@ public static AstElem ParseScript(Script sc)
 		*/
 
 
-		public static Terminal ParseScript(Script sc) =>
+		public static Terminal<TPk, TPKh> ParseScript<TPk, TPKh>(Script sc)
+			where TPk : IMiniscriptKey<TPKh>
+			where TPKh : IMiniscriptKeyHash
+			=>
 			throw new NotImplementedException();
 
-		private class TerminalStack
+		private class TerminalStack<TPk, TPKh>
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 		{
-			internal readonly Stack<Miniscript> Inner;
-			internal TerminalStack(Stack<Miniscript> inner)
+			internal readonly Stack<Miniscript<TPk, TPKh>> Inner;
+			internal TerminalStack(Stack<Miniscript<TPk, TPKh>> inner)
 			{
 				Inner = inner;
 			}
 
-			internal Miniscript Pop() =>
+			internal Miniscript<TPk, TPKh> Pop() =>
 				this.Inner.Pop();
 
-			internal void Reduce0(Terminal ms)
+			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(ty, ms, ext));
+				this.Inner.Push(new Miniscript<TPk, TPKh>(ty, ms, ext));
 			}
 
-			internal void Reduce1(Func<Miniscript, Terminal> wrap)
+			internal void Reduce1(Func<Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> wrap)
 			{
-				var top = this.Pop();
-				var wrappedMs = wrap(top);
-				var ty = MiniscriptFragmentType.TypeCheck(wrappedMs, _ => null);
-				var ext = ExtData.TypeCheck(wrappedMs, _ => null);
-				this.Inner.Push(new Miniscript(ty, wrappedMs, ext));
+				throw new NotImplementedException();
 			}
 
-			internal void Reduce2(Func<Miniscript, Miniscript, Terminal> wrap)
+			internal void Reduce2(Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> wrap)
 			{
-				var left = this.Pop();
-				var right = this.Pop();
-				var wrappedMs = wrap(left, right);
-				var ty = MiniscriptFragmentType.TypeCheck(wrappedMs, _ => null);
-				var ext = ExtData.TypeCheck(wrappedMs, _ => null);
-				this.Inner.Push(new Miniscript(ty, wrappedMs, ext));
+				throw new NotImplementedException();
 			}
 		}
 
@@ -445,10 +435,12 @@ private static void MatchToken(ScriptToken tokens)
 		{
 			throw new NotImplementedException();
 		}
-		public static Miniscript<TPk> ParseScriptToken(ScriptToken sct)
+		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(new Stack<Miniscript>());
+			var term = new TerminalStack<TPk, TPKh>(new Stack<Miniscript<TPk, TPKh>>());
 
 			nonTerm.Push(NonTerm.MaybeAndV);
 			nonTerm.Push(NonTerm.MaybeSwap);
@@ -461,6 +453,7 @@ public static Miniscript<TPk> ParseScriptToken(ScriptToken sct)
 				if (popped == NonTerm.Expression)
 				{}
 			}
+			throw new NotImplementedException();
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
index 916cbd5df7..e501a80eb5 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
@@ -7,7 +7,9 @@
 
 namespace NBitcoin.Scripting.Miniscript.Policy
 {
-	public class AbstractPolicy<TPk> : IEquatable<AbstractPolicy<TPk>> where TPk : IMiniscriptKey
+	public class AbstractPolicy<TPk, TPKh> : IEquatable<AbstractPolicy<TPk, TPKh>>
+		where TPKh : IMiniscriptKeyHash
+		where TPk : IMiniscriptKey<TPKh>
 	{
 		#region Subtype definitions
 		internal static class Tags
@@ -29,19 +31,19 @@ internal static class Tags
 		private int Tag;
 		private AbstractPolicy(int tag) => Tag = tag;
 
-		public static AbstractPolicy<TPk> UnSatisfiable { get; } = new AbstractPolicy<TPk>(Tags.Unsatisfiable);
-		public static AbstractPolicy<TPk> Trivial { get; } = new AbstractPolicy<TPk>(Tags.Trivial);
+		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>
+		internal class KeyHash : AbstractPolicy<TPk, TPKh>
 		{
-			internal IMiniscriptKeyHash Item;
-			internal KeyHash(IMiniscriptKeyHash item) : base(Tags.KeyHash)
+			internal TPKh Item;
+			internal KeyHash(TPKh item) : base(Tags.KeyHash)
 			{
 				Item = item;
 			}
 		}
 
-		internal class After : AbstractPolicy<TPk>
+		internal class After : AbstractPolicy<TPk, TPKh>
 		{
 			internal uint Item;
 
@@ -51,7 +53,7 @@ public After(uint item) : base (Tags.After)
 			}
 		}
 
-		internal class Older : AbstractPolicy<TPk>
+		internal class Older : AbstractPolicy<TPk, TPKh>
 		{
 			internal uint Item;
 
@@ -61,7 +63,7 @@ public Older(uint item) : base (Tags.Older)
 			}
 		}
 
-		internal class Sha256 : AbstractPolicy<TPk>
+		internal class Sha256 : AbstractPolicy<TPk, TPKh>
 		{
 			internal uint256 Item;
 
@@ -71,7 +73,7 @@ public Sha256(uint256 item) :base(Tags.Sha256)
 			}
 		}
 
-		internal class Hash256 : AbstractPolicy<TPk>
+		internal class Hash256 : AbstractPolicy<TPk, TPKh>
 		{
 			internal uint256 Item;
 
@@ -81,7 +83,7 @@ public Hash256(uint256 item) :base(Tags.Hash256)
 			}
 		}
 
-		internal class Ripemd160 : AbstractPolicy<TPk>
+		internal class Ripemd160 : AbstractPolicy<TPk, TPKh>
 		{
 			internal uint160 Item;
 
@@ -91,7 +93,7 @@ public Ripemd160(uint160 item) :base(Tags.Ripemd160)
 			}
 		}
 
-		internal class Hash160 : AbstractPolicy<TPk>
+		internal class Hash160 : AbstractPolicy<TPk, TPKh>
 		{
 			internal uint160 Item;
 
@@ -101,50 +103,50 @@ public Hash160(uint160 item) :base(Tags.Hash160)
 			}
 		}
 
-		internal class And : AbstractPolicy<TPk>
+		internal class And : AbstractPolicy<TPk, TPKh>
 		{
-			internal List<AbstractPolicy<TPk>> Item;
+			internal List<AbstractPolicy<TPk, TPKh>> Item;
 
-			public And(List<AbstractPolicy<TPk>> item) : base(Tags.And)
+			public And(List<AbstractPolicy<TPk, TPKh>> item) : base(Tags.And)
 			{
 				Item = item;
 			}
 		}
 
-		internal class Or : AbstractPolicy<TPk>
+		internal class Or : AbstractPolicy<TPk, TPKh>
 		{
-			internal List<AbstractPolicy<TPk>> Item;
+			internal List<AbstractPolicy<TPk, TPKh>> Item;
 
-			public Or(List<AbstractPolicy<TPk>> item) : base(Tags.Or)
+			public Or(List<AbstractPolicy<TPk, TPKh>> item) : base(Tags.Or)
 			{
 				Item = item;
 			}
 		}
 
-		internal class Threshold : AbstractPolicy<TPk>
+		internal class Threshold : AbstractPolicy<TPk, TPKh>
 		{
 			internal uint Item1;
-			internal List<AbstractPolicy<TPk>> Item2;
+			internal List<AbstractPolicy<TPk, TPKh>> Item2;
 
-			public Threshold(uint item1, List<AbstractPolicy<TPk>> item2) : base (Tags.Threshold)
+			public Threshold(uint item1, List<AbstractPolicy<TPk, TPKh>> item2) : base (Tags.Threshold)
 			{
 				Item1 = item1;
 				Item2 = item2;
 			}
 		}
 
-		public static AbstractPolicy<TPk> NewUnsatisfiable() => UnSatisfiable;
-		public static AbstractPolicy<TPk> NewTrivial() => Trivial;
-		public static AbstractPolicy<TPk> NewKeyHash(IMiniscriptKeyHash item) => new KeyHash(item);
-		public static AbstractPolicy<TPk> NewAfter(uint item) => new After(item);
-		public static AbstractPolicy<TPk> NewOlder(uint item) => new Older(item);
-		public static AbstractPolicy<TPk> NewSha256(uint256 item) => new Sha256(item);
-		public static AbstractPolicy<TPk> NewHash256(uint256 item) => new Hash256(item);
-		public static AbstractPolicy<TPk> NewRipemd160(uint160 item) => new Ripemd160(item);
-		public static AbstractPolicy<TPk> NewHash160(uint160 item) => new Hash160(item);
-		public static AbstractPolicy<TPk> NewAnd(List<AbstractPolicy<TPk>> item) => new And(item);
-		public static AbstractPolicy<TPk> NewOr(List<AbstractPolicy<TPk>> item) => new Or(item);
-		public static AbstractPolicy<TPk> NewThreshold(uint item1, List<AbstractPolicy<TPk>> item2) => new Threshold(item1, 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(List<AbstractPolicy<TPk, TPKh>> item) => new And(item);
+		public static AbstractPolicy<TPk, TPKh> NewOr(List<AbstractPolicy<TPk, TPKh>> item) => new Or(item);
+		public static AbstractPolicy<TPk, TPKh> NewThreshold(uint item1, List<AbstractPolicy<TPk, TPKh>> item2) => new Threshold(item1, item2);
 
 		#endregion
 
@@ -213,7 +215,7 @@ public override int GetHashCode()
 		}
 
 
-		public bool Equals(AbstractPolicy<TPk> other)
+		public bool Equals(AbstractPolicy<TPk, TPKh> other)
 		{
 			if (other == null)
 				return false;
@@ -241,13 +243,13 @@ public bool Equals(AbstractPolicy<TPk> other)
 				case Hash160 self:
 					return self.Item.Equals(((Hash160)other).Item);
 				case And self:
-					var andSet = new HashSet<AbstractPolicy<TPk>>(self.Item);
+					var andSet = new HashSet<AbstractPolicy<TPk, TPKh>>(self.Item);
 					return andSet.SetEquals(((And)other).Item);
 				case Or self:
-					var orSet = new HashSet<AbstractPolicy<TPk>>(self.Item);
+					var orSet = new HashSet<AbstractPolicy<TPk, TPKh>>(self.Item);
 					return orSet.SetEquals(((Or)other).Item);
 				case Threshold self:
-					var subSet = new HashSet<AbstractPolicy<TPk>>(self.Item2);
+					var subSet = new HashSet<AbstractPolicy<TPk, TPKh>>(self.Item2);
 					var o = (Threshold) other;
 					return (self.Item1 == o.Item1) && (subSet.SetEquals(o.Item2));
 			}
@@ -256,16 +258,16 @@ public bool Equals(AbstractPolicy<TPk> other)
 
 		#endregion
 
-		public static AbstractPolicy<TPk> FromTree<T>(Tree<T> top)
+		public static AbstractPolicy<TPk, TPKh> FromTree<T>(Tree<T> top)
 		{
 			var n = top.Name;
 			var l = top.Args.Length;
 			if (n == "UNSATISFIABLE" && l == 0)
-				return AbstractPolicy<TPk>.UnSatisfiable;
+				return AbstractPolicy<TPk, TPKh>.UnSatisfiable;
 			if (n == "TRIVIAL" && l == 0)
-				return AbstractPolicy<TPk>.Trivial;
+				return AbstractPolicy<TPk, TPKh>.Trivial;
 			//if (n == "pkh" && l == 1)
-				// return AbstractPolicy<TPk>.KeyHash;
+				// return AbstractPolicy<TPk, TPKh>.KeyHash;
 			throw new NotImplementedException();
 		}
 
@@ -274,12 +276,12 @@ public static AbstractPolicy<TPk> FromTree<T>(Tree<T> top)
 		/// `Unsatisfiable`'s Does not reorder any branches; use `.sort`
 		/// </summary>
 		/// <returns></returns>
-		public AbstractPolicy<TPk> Normalize()
+		public AbstractPolicy<TPk, TPKh> Normalize()
 		{
 			switch (this)
 			{
 				case And self:
-					var retSubsAnd = new List<AbstractPolicy<TPk>>();
+					var retSubsAnd = new List<AbstractPolicy<TPk, TPKh>>();
 					foreach (var sub in self.Item)
 					{
 						var s = sub.Normalize();
@@ -308,7 +310,7 @@ public AbstractPolicy<TPk> Normalize()
 						return NewAnd(retSubsAnd);
 
 				case Or self:
-					var retSubsOr = new List<AbstractPolicy<TPk>>();
+					var retSubsOr = new List<AbstractPolicy<TPk, TPKh>>();
 					foreach (var sub in self.Item)
 					{
 						if (sub == Trivial) return Trivial;
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index 04c9fcbbb7..5cb3cd3da1 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -6,7 +6,14 @@
 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!");
+
+		private CompilerException(string msg) : base(msg) {}
+	}
 
 	/// <summary>
 	/// This represents the state of the best possible compilation
@@ -63,14 +70,180 @@ internal class CompilerExtData : IProperty<CompilerExtData>
 		/// </summary>
 		internal readonly double SatisfyCost;
 		internal readonly double? DissatCost;
+		public void SanityChecks()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData FromTrue()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData FromFalse()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData FromPk()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData FromPkH()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData FromMulti(int k, int pkLength)
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData FromAfter(uint time)
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData FromOlder(uint time)
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData FromHash()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData FromSha256()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData FromHash256()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData FromRipemd160()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData FromHash160()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData CastAlt()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData CastSwap()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData CastCheck()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData CastDupIf()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData CastVerify()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData CastNonZero()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData CastZeroNotEqual()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData CastTrue()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData CastOrIFalse()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData CastUnLikely()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData CastLikely()
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData AndB(CompilerExtData left, CompilerExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData AndV(CompilerExtData left, CompilerExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData AndN(CompilerExtData left, CompilerExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData OrB(CompilerExtData left, CompilerExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData OrD(CompilerExtData left, CompilerExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData OrC(CompilerExtData left, CompilerExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData OrI(CompilerExtData left, CompilerExtData right)
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData AndOr(CompilerExtData a, CompilerExtData b, CompilerExtData c)
+		{
+			throw new NotImplementedException();
+		}
+
+		public CompilerExtData Threshold(int k, int n, Func<uint, CompilerExtData> subCk)
+		{
+			throw new NotImplementedException();
+		}
 	}
 
-	internal class AstElemExt<TPk> where TPk : IMiniscriptKey
+	internal class AstElemExt<TPk, TPKh>
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 	{
-		internal readonly Miniscript<TPk> Ms;
+		internal readonly Miniscript<TPk, TPKh> Ms;
 		internal readonly CompilerExtData CompExtData;
 
-		public AstElemExt(CompilerExtData compilerExtData, Miniscript<TPk> ms)
+		public AstElemExt(CompilerExtData compilerExtData, Miniscript<TPk, TPKh> ms)
 		{
 			CompExtData = compilerExtData;
 			Ms = ms;
@@ -98,14 +271,14 @@ internal double Cost1d(double satProb, double? dissatProb)
 
 		}
 
-		internal static AstElemExt<TPk> Terminal(Terminal<TPk> ast)
+		internal static AstElemExt<TPk, TPKh> Terminal(Terminal<TPk, TPKh> ast)
 		{
 			CompilerExtData compExtData = default;
-			Miniscript<TPk> ms = default;
-			return new AstElemExt<TPk>(compExtData.TypeCheck(ast), Miniscript<TPk>.FromAst(ast));
+			Miniscript<TPk, TPKh> ms = default;
+			return new AstElemExt<TPk, TPKh>(compExtData.TypeCheck(ast), Miniscript<TPk, TPKh>.FromAst(ast));
 		}
 
-		internal static AstElemExt<TPk> Binary(Terminal<TPk> ast, AstElemExt<TPk> l, AstElemExt<TPk> r)
+		internal static AstElemExt<TPk, TPKh> Binary(Terminal<TPk, TPKh> ast, AstElemExt<TPk, TPKh> l, AstElemExt<TPk, TPKh> r)
 		{
 			MiniscriptFragmentType ty = default;
 			ty = ty.TypeCheck(ast);
@@ -117,14 +290,14 @@ internal static AstElemExt<TPk> Binary(Terminal<TPk> ast, AstElemExt<TPk> l, Ast
 			CompilerExtData compExtData = default;
 			compExtData = compExtData.TypeCheck(ast, lookupExt);
 
-			return new AstElemExt<TPk>(compExtData, new Miniscript<TPk>(ty, ast, ext));
+			return new AstElemExt<TPk, TPKh>(compExtData, new Miniscript<TPk, TPKh>(ty, ast, ext));
 		}
 
-		internal static AstElemExt<TPk> Ternary(
-			Terminal<TPk> ast,
-			AstElemExt<TPk> a,
-			AstElemExt<TPk> b,
-			AstElemExt<TPk> c
+		internal static AstElemExt<TPk, TPKh> Ternary(
+			Terminal<TPk, TPKh> ast,
+			AstElemExt<TPk, TPKh> a,
+			AstElemExt<TPk, TPKh> b,
+			AstElemExt<TPk, TPKh> c
 		)
 		{
 			Func<int, CompilerExtData> lookupExt =
@@ -141,18 +314,20 @@ AstElemExt<TPk> c
 			CompilerExtData compilerExtData = default;
 			compilerExtData = compilerExtData.TypeCheck(ast, lookupExt);
 
-			return new AstElemExt<TPk>(compilerExtData, new Miniscript<TPk>(ty, ast, ext));
+			return new AstElemExt<TPk, TPKh>(compilerExtData, new Miniscript<TPk, TPKh>(ty, ast, ext));
 		}
 	}
 
-	internal class Cast<TPk> where TPk : IMiniscriptKey
+	internal class Cast<TPk, TPKh>
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 	{
-		public Func<Miniscript<TPk>, Terminal<TPk>> Node;
+		public Func<Terminal<TPk, TPKh>> Node;
 		public Func<MiniscriptFragmentType> AstType;
 		public Func<ExtData> ExtData;
 		public Func<CompilerExtData> CompilerExtData;
 
-		public Cast(Func<ExtData> extData, Func<MiniscriptFragmentType> astType, Func<Miniscript<TPk>, Terminal<TPk>> node, Func<CompilerExtData> compilerExtData)
+		public Cast(Func<ExtData> extData, Func<MiniscriptFragmentType> astType, Func<Terminal<TPk, TPKh>> node, Func<CompilerExtData> compilerExtData)
 		{
 			ExtData = extData;
 			AstType = astType;
@@ -160,39 +335,193 @@ public Cast(Func<ExtData> extData, Func<MiniscriptFragmentType> astType, Func<Mi
 			CompilerExtData = compilerExtData;
 		}
 
-		public AstElemExt<TPk> InvokeCast(AstElemExt<TPk> ast)
-		=>
-			new AstElemExt<TPk>(
-				ms: new Miniscript<TPk>(
-					this.AstType.Invoke(ast.Ms.Type),
-					this.Node.Invoke(ast.Ms),
-					this.ExtData.Invoke(ast.Ms.Ext)
+		public AstElemExt<TPk, TPKh> InvokeCast()
+			=>
+				new AstElemExt<TPk, TPKh>(
+					compilerExtData: this.CompilerExtData.Invoke(),
+					ms: new Miniscript<TPk, TPKh>(
+						this.AstType.Invoke(),
+						this.Node.Invoke(),
+						this.ExtData.Invoke()
 
-				),
-				compilerExtData:this.CompilerExtData.Invoke(ast.CompExtData));
+					));
 
-		public List<Cast<TPk>> AllCasts()
-		{
-			ExtData extD = default;
-			Terminal<TPk> term = default;
-			MiniscriptFragmentType astType = default;
-			CompilerExtData compilerExtData = default;
-			return
-				new List<Cast<TPk>>()
-				{
-					new Cast<TPk>(
-						extD.CastCheck,
-						astType.TypeCheck,
-						Terminal<TPk>.NewCheck,
-						compilerExtData.CastCheck
+		public static List<Cast<TPk, TPKh>> GetAllCasts(AstElemExt<TPk, TPKh> ast)
+			=> new List<Cast<TPk, TPKh>>()
+			{
+				new Cast<TPk, TPKh>(
+					ast.Ms.Ext.CastCheck,
+					ast.Ms.Type.CastCheck,
+					() => Terminal<TPk, TPKh>.NewCheck(ast.Ms),
+					ast.CompExtData.CastCheck
+				),
+				new Cast<TPk, TPKh>(
+					ast.Ms.Ext.CastDupIf,
+					ast.Ms.Type.CastDupIf,
+					() => Terminal<TPk, TPKh>.NewDupIf(ast.Ms),
+					ast.CompExtData.CastDupIf
 					),
-					new Cast<TPk>()
-				};
-		}
+				new Cast<TPk, TPKh>(
+					ast.Ms.Ext.CastLikely,
+					ast.Ms.Type.CastLikely,
+					() => Terminal<TPk, TPKh>.NewOrI(Miniscript<TPk, TPKh>.FromAst(Terminal<TPk, TPKh>.False), ast.Ms),
+					ast.CompExtData.CastLikely
+					),
+				new Cast<TPk, TPKh>(
+					ast.Ms.Ext.CastUnLikely,
+					ast.Ms.Type.CastUnLikely,
+					() => Terminal<TPk, TPKh>.NewOrI(Miniscript<TPk, TPKh>.FromAst(Terminal<TPk, TPKh>.False), ast.Ms),
+					ast.CompExtData.CastUnLikely
+					),
+				new Cast<TPk, TPKh>(
+					ast.Ms.Ext.CastVerify,
+					ast.Ms.Type.CastVerify,
+					() => Terminal<TPk, TPKh>.NewVerify(ast.Ms),
+					ast.CompExtData.CastVerify
+					),
+				new Cast<TPk, TPKh>(
+					ast.Ms.Ext.CastNonZero,
+					ast.Ms.Type.CastNonZero,
+					() => Terminal<TPk, TPKh>.NewNonZero(ast.Ms),
+					ast.CompExtData.CastNonZero
+					),
+				new Cast<TPk, TPKh>(
+					ast.Ms.Ext.CastTrue,
+					ast.Ms.Type.CastTrue,
+					() => Terminal<TPk, TPKh>.NewAndV(ast.Ms, Miniscript<TPk, TPKh>.FromAst(Terminal<TPk, TPKh>.True)),
+					ast.CompExtData.CastTrue
+					),
+				new Cast<TPk, TPKh>(
+					ast.Ms.Ext.CastSwap,
+					ast.Ms.Type.CastSwap,
+					() => Terminal<TPk, TPKh>.NewSwap(ast.Ms),
+					ast.CompExtData.CastSwap
+					),
+				new Cast<TPk, TPKh>(
+					ast.Ms.Ext.CastAlt,
+					ast.Ms.Type.CastAlt,
+					() => Terminal<TPk, TPKh>.NewAlt(ast.Ms),
+					ast.CompExtData.CastAlt
+					),
+				new Cast<TPk, TPKh>(
+					ast.Ms.Ext.CastZeroNotEqual,
+					ast.Ms.Type.CastZeroNotEqual,
+					() => Terminal<TPk, TPKh>.NewZeroNotEqual(ast.Ms),
+					ast.CompExtData.CastZeroNotEqual
+					),
+			};
 	}
 
-	public static class Compiler
+	public static class Compiler<TPk, TPKh>
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 	{
+		private static void InsertElem(
+			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> map,
+			AstElemExt<TPk, TPKh> astElemExt,
+			double SatProb,
+			double? dissatProb
+		)
+		{
+			throw new NotImplementedException();
+		}
+
+		/// <summary>
+		/// Get teh 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>> BestCompilation(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+				policyCache,
+			ConcretePolicy<TPk, TPKh> policy,
+			double satProb,
+			double? dissatProb
+		)
+		{
+			throw new NotImplementedException();
+		}
+
+		private static void CompileBinary(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, 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
+		)
+		{
+			throw new NotImplementedException();
+		}
+
+		private static void CompileTernary(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, 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,
+			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> binFunc
+			)
+		{
+		}
+
+		public static Miniscript<TPk, TPKh> BestCompilation(ConcretePolicy<TPk, TPKh> policy)
+		{
+			var policyCache =
+				new Dictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, 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;
+		}
 
+		private static AstElemExt<TPk, TPKh> BestT(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+				policyCache,
+			ConcretePolicy<TPk, TPKh> policy,
+			double satProb,
+			double? dissatProb
+			)
+		{
+			throw new NotImplementedException();
+		}
+
+		private static AstElemExt<TPk, TPKh> BestE(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+				policyCache,
+				ConcretePolicy<TPk, TPKh> policy,
+				double satProb,
+				double? dissatProb
+			)
+		{
+			throw new NotImplementedException();
+		}
+
+		private static AstElemExt<TPk, TPKh> BestW(
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+				policyCache,
+				ConcretePolicy<TPk, TPKh> policy,
+				double satProb,
+				double? dissatProb
+			)
+		{
+			throw new NotImplementedException();
+		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
index 8cb131a7b9..759aecae15 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
@@ -32,7 +32,9 @@ public enum PolicyError
 		/// </summary>
 		TimeTooFar
 	}
-	public class ConcretePolicy<TPk> : IEquatable<ConcretePolicy<TPk>>, ILiftable<TPk> where TPk : IMiniscriptKey
+	public class ConcretePolicy<TPk, TPKh> : IEquatable<ConcretePolicy<TPk, TPKh>>, ILiftable<TPk, TPKh>
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 	{
 		#region Subtype definitions
 
@@ -55,102 +57,102 @@ private static class Tags
 
 		private ConcretePolicy(int tag) => Tag = tag;
 
-		internal class Key : ConcretePolicy<TPk>
+		internal class Key : ConcretePolicy<TPk, TPKh>
 		{
 			public TPk Item;
 			public Key(TPk item) : base(Tags.Key) => Item = item;
 		}
 
-		internal class After : ConcretePolicy<TPk>
+		internal class After : ConcretePolicy<TPk, TPKh>
 		{
 			public uint Item;
 
 			public After(uint item) : base(Tags.After) => Item = item;
 		}
 
-		internal class Older : ConcretePolicy<TPk>
+		internal class Older : ConcretePolicy<TPk, TPKh>
 		{
 			public uint Item;
 
 			public Older(uint item) : base(Tags.Older) => Item = item;
 		}
 
-		internal class Sha256 : ConcretePolicy<TPk>
+		internal class Sha256 : ConcretePolicy<TPk, TPKh>
 		{
 			public uint256 Item;
 
 			public Sha256(uint256 item) : base(Tags.Sha256) => Item = item;
 		}
 
-		internal class Hash256 : ConcretePolicy<TPk>
+		internal class Hash256 : ConcretePolicy<TPk, TPKh>
 		{
 			public uint256 Item;
 
 			public Hash256(uint256 item) : base(Tags.Hash256) => Item = item;
 		}
 
-		internal class Ripemd160 : ConcretePolicy<TPk>
+		internal class Ripemd160 : ConcretePolicy<TPk, TPKh>
 		{
 			public uint160 Item;
 
 			public Ripemd160(uint160 item) : base(Tags.Ripemd160) => Item = item;
 		}
 
-		internal class Hash160 : ConcretePolicy<TPk>
+		internal class Hash160 : ConcretePolicy<TPk, TPKh>
 		{
 			public uint160 Item;
 			public Hash160(uint160 item) : base(Tags.Hash160) => Item = item;
 		}
 
-		internal class And : ConcretePolicy<TPk>
+		internal class And : ConcretePolicy<TPk, TPKh>
 		{
-			public List<ConcretePolicy<TPk>> Item;
+			public List<ConcretePolicy<TPk, TPKh>> Item;
 
-			public And(List<ConcretePolicy<TPk>> item) : base(Tags.And)
+			public And(List<ConcretePolicy<TPk, TPKh>> item) : base(Tags.And)
 			{
 				Item = item;
 			}
 		}
 
-		internal class Or : ConcretePolicy<TPk>
+		internal class Or : ConcretePolicy<TPk, TPKh>
 		{
-			public List<Tuple<uint, ConcretePolicy<TPk>>> Item;
+			public List<Tuple<uint, ConcretePolicy<TPk, TPKh>>> Item;
 
-			public Or(List<Tuple<uint, ConcretePolicy<TPk>>> item) : base(Tags.Or)
+			public Or(List<Tuple<uint, ConcretePolicy<TPk, TPKh>>> item) : base(Tags.Or)
 			{
 				Item = item;
 			}
 		}
 
-		internal class Threshold : ConcretePolicy<TPk>
+		internal class Threshold : ConcretePolicy<TPk, TPKh>
 		{
 			public uint Item1;
-			public List<ConcretePolicy<TPk>> Item2;
+			public List<ConcretePolicy<TPk, TPKh>> Item2;
 
-			public Threshold(uint item1, List<ConcretePolicy<TPk>> item2) : base(Tags.Threshold)
+			public Threshold(uint item1, List<ConcretePolicy<TPk, TPKh>> item2) : base(Tags.Threshold)
 			{
 				Item1 = item1;
 				Item2 = item2;
 			}
 		}
 
-		public static ConcretePolicy<TPk> NewKey(TPk pk) => new Key(pk);
-		public static ConcretePolicy<TPk> NewAfter(uint time) => new After(time);
-		public static ConcretePolicy<TPk> NewOlder(uint item) => new Older(item);
-		public static ConcretePolicy<TPk> NewSha256(uint256 item) => new Sha256(item);
-		public static ConcretePolicy<TPk> NewHash256(uint256 item) => new Hash256(item);
-		public static ConcretePolicy<TPk> NewRipemd160(uint160 item) => new Ripemd160(item);
-		public static ConcretePolicy<TPk> NewHash160(uint160 item) => new Hash160(item);
-		public static ConcretePolicy<TPk> NewAnd(IEnumerable<ConcretePolicy<TPk>> subs) => new And(subs.ToList());
-		public static ConcretePolicy<TPk> NewOr(IEnumerable<Tuple<uint, ConcretePolicy<TPk>>> item) => new Or(item.ToList());
-		public static ConcretePolicy<TPk> NewThreshold(uint k, IEnumerable<ConcretePolicy<TPk>> subs) => new Threshold(k, subs.ToList());
+		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> other)
+		public bool Equals(ConcretePolicy<TPk, TPKh> other)
 		{
 			if (other == null || this.Tag != other.Tag)
 				return false;
@@ -171,14 +173,14 @@ public bool Equals(ConcretePolicy<TPk> other)
 				case Hash160 self:
 					return self.Item.Equals(((Hash160) other).Item);
 				case And self:
-					var andSet = new HashSet<ConcretePolicy<TPk>>(self.Item);
+					var andSet = new HashSet<ConcretePolicy<TPk, TPKh>>(self.Item);
 					return andSet.SetEquals(((And)other).Item);
 				case Or self:
-					var orSet = new HashSet<Tuple<uint, ConcretePolicy<TPk>>>(self.Item);
+					var orSet = new HashSet<Tuple<uint, ConcretePolicy<TPk, TPKh>>>(self.Item);
 					return orSet.SetEquals(((Or)other).Item);
 				case Threshold self:
 					var thres = (Threshold) other;
-					var threshSet = new HashSet<ConcretePolicy<TPk>>(self.Item2);
+					var threshSet = new HashSet<ConcretePolicy<TPk, TPKh>>(self.Item2);
 					return self.Item1 == thres.Item1 && threshSet.SetEquals(thres.Item2);
 			}
 			throw new Exception("Unreachable!");
@@ -238,40 +240,40 @@ public override int GetHashCode()
 			throw new Exception("Unreachable!");
 		}
 
-		public AbstractPolicy<TPk> Lift()
+		public AbstractPolicy<TPk, TPKh> Lift()
 		{
-			AbstractPolicy<TPk> res = null;
+			AbstractPolicy<TPk, TPKh> res = null;
 			switch (this)
 			{
 				case Key self:
-					res = AbstractPolicy<TPk>.NewKeyHash(self.Item.MiniscriptKeyHash);
+					res = AbstractPolicy<TPk, TPKh>.NewKeyHash(self.Item.ToPubKeyHash());
 					break;
 				case After self:
-					res = AbstractPolicy<TPk>.NewAfter(self.Item);
+					res = AbstractPolicy<TPk, TPKh>.NewAfter(self.Item);
 					break;
 				case Older self:
-					res = AbstractPolicy<TPk>.NewOlder(self.Item);
+					res = AbstractPolicy<TPk, TPKh>.NewOlder(self.Item);
 					break;
 				case Sha256 self:
-					res = AbstractPolicy<TPk>.NewSha256(self.Item);
+					res = AbstractPolicy<TPk, TPKh>.NewSha256(self.Item);
 					break;
 				case Hash256 self:
-					res = AbstractPolicy<TPk>.NewHash256(self.Item);
+					res = AbstractPolicy<TPk, TPKh>.NewHash256(self.Item);
 					break;
 				case Ripemd160 self:
-					res = AbstractPolicy<TPk>.NewRipemd160(self.Item);
+					res = AbstractPolicy<TPk, TPKh>.NewRipemd160(self.Item);
 					break;
 				case Hash160 self:
-					res = AbstractPolicy<TPk>.NewHash160(self.Item);
+					res = AbstractPolicy<TPk, TPKh>.NewHash160(self.Item);
 					break;
 				case And self:
-					res = AbstractPolicy<TPk>.NewAnd(self.Item.Select(sub => sub.Lift()).ToList());
+					res = AbstractPolicy<TPk, TPKh>.NewAnd(self.Item.Select(sub => sub.Lift()).ToList());
 					break;
 				case Or self:
-					res = AbstractPolicy<TPk>.NewOr(self.Item.Select(sub => sub.Item2.Lift()).ToList());
+					res = AbstractPolicy<TPk, TPKh>.NewOr(self.Item.Select(sub => sub.Item2.Lift()).ToList());
 					break;
 				case Threshold self:
-					res = AbstractPolicy<TPk>.NewThreshold(self.Item1, self.Item2.Select(sub => sub.Lift()).ToList());
+					res = AbstractPolicy<TPk, TPKh>.NewThreshold(self.Item1, self.Item2.Select(sub => sub.Lift()).ToList());
 					break;
 			}
 
@@ -280,7 +282,7 @@ public AbstractPolicy<TPk> Lift()
 		}
 
 		public override bool Equals(object obj) =>
-			Equals(obj as ConcretePolicy<TPk>);
+			Equals(obj as ConcretePolicy<TPk, TPKh>);
 
 		#endregion
 
@@ -450,13 +452,13 @@ private StringBuilder ToStringCore(StringBuilder sb)
 			throw new Exception("Unreachable!");
 		}
 
-		public static ConcretePolicy<TPk> FromTree()
+		public static ConcretePolicy<TPk, TPKh> FromTree()
 		{
 
 			throw new NotImplementedException("");
 		}
 
-		private static Tuple<uint, ConcretePolicy<TPk>> FromTreeProb<T>(Tree<T> top, bool allowProb)
+		private static Tuple<uint, ConcretePolicy<TPk, TPKh>> FromTreeProb<T>(Tree<T> top, bool allowProb)
 		{
 			int fragProb = default;
 			string fragName = default;
diff --git a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
index c671ad146a..1a60a7b297 100644
--- a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
@@ -136,16 +136,18 @@ public enum ErrorKind
 		ThresholdNotStrong
 	}
 
-	class TypeCheckException<TPk> : Exception where TPk : IMiniscriptKey
+	class TypeCheckException<TPk, TPKh> : Exception
+		where TPk : IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 	{
-		public readonly Terminal<TPk> Fragment;
+		public readonly Terminal<TPk, TPKh> Fragment;
 		public readonly ErrorKind Kind;
 		public readonly int[] Items;
-		public TypeCheckException(Terminal<TPk> fragment, ErrorKind kind)
+		public TypeCheckException(Terminal<TPk, TPKh> fragment, ErrorKind kind)
 			: this(fragment, kind, new int[] { })
 		{}
 
-		public TypeCheckException(Terminal<TPk> fragment, ErrorKind kind, int[] items):
+		public TypeCheckException(Terminal<TPk, TPKh> fragment, ErrorKind kind, int[] items):
 			base($"Error: {kind.ToString("G")}. Fragment: {fragment}, items: {items.Select(i => i.ToString()).Aggregate((str, i) => $"{str}, {i}")}")
 
 		{
@@ -171,22 +173,28 @@ public static class PropertyExtensions
 		/// <typeparam name="T"></typeparam>
 		/// <exception cref="TypeCheckException"></exception>
 		/// <returns></returns>
-		internal static T TypeCheck<T, TPk>(this T prop, Terminal<TPk> fragment, Func<int, T> child) where T : class, IProperty<T>
-		where TPk : IMiniscriptKey
+		internal static T TypeCheck<T, TPk, TPKh>(this T prop, Terminal<TPk, TPKh> fragment, Func<int, T> child)
+			where T : class, IProperty<T>
+			where TPk : IMiniscriptKey<TPKh>
+			where TPKh : IMiniscriptKeyHash
 		{
 			var res = prop.TypeCheckCore(fragment, child);
 			res.SanityChecks();
 			return res;
 		}
 
-		internal static T TypeCheck<T, TPk>(this T prop, Terminal<TPk> fragment) where T : class, IProperty<T>
-			where TPk : IMiniscriptKey
+		internal static T TypeCheck<T, TPk, TPKh>(this T prop, Terminal<TPk, TPKh> fragment)
+			where T : class, IProperty<T>
+			where TPk : IMiniscriptKey<TPKh>
+			where TPKh : IMiniscriptKeyHash
 			=> prop.TypeCheck(fragment, (_) => null);
 
-		private static T TypeCheckCore<T, TPk>(this T prop, Terminal<TPk> fragment,Func<int, T> child) where T : class, IProperty<T>
-		where TPk : IMiniscriptKey
+		private static T TypeCheckCore<T, TPk, TPKh>(this T prop, Terminal<TPk, TPKh> fragment,Func<int, T> child)
+			where T : class, IProperty<T>
+			where TPk : IMiniscriptKey<TPKh>
+			where TPKh : IMiniscriptKeyHash
 		{
-			T GetChild(Terminal<TPk> sub, int n)
+			T GetChild(Terminal<TPk, TPKh> sub, int n)
 				{
 					try
 					{
@@ -199,102 +207,102 @@ T GetChild(Terminal<TPk> sub, int n)
 				}
 			switch (fragment.Tag)
 			{
-				case Terminal<TPk>.Tags.True:
+				case Terminal<TPk, TPKh>.Tags.True:
 					return prop.FromTrue();
-				case Terminal<TPk>.Tags.False:
+				case Terminal<TPk, TPKh>.Tags.False:
 					return prop.FromFalse();
 			}
 
 			switch (fragment)
 			{
-				case Terminal<TPk>.Pk self:
+				case Terminal<TPk, TPKh>.Pk self:
 					return prop.FromPk();
-				case Terminal<TPk>.PkH self:
+				case Terminal<TPk, TPKh>.PkH self:
 					return prop.FromPkH();
-				case Terminal<TPk>.ThreshM self:
+				case Terminal<TPk, TPKh>.ThreshM self:
 					if (self.Item1 == 0)
 					{
-						throw new TypeCheckException<TPk>(fragment, ErrorKind.ZeroThreshold);
+						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroThreshold);
 					}
 
 					if (self.Item1 > self.Item2.Length)
 					{
-						throw new TypeCheckException<TPk>(
+						throw new TypeCheckException<TPk, TPKh>(
 							fragment,
 							ErrorKind.OverThreshold,
 							new int[] {self.Item1, self.Item2.Length});
 					}
 					return prop.FromMulti(self.Item1, self.Item2.Length);
-				case Terminal<TPk>.After self:
+				case Terminal<TPk, TPKh>.After self:
 					if (self.Item == 0)
 					{
-						throw new TypeCheckException<TPk>(fragment, ErrorKind.ZeroTime);
+						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroTime);
 					}
 
 					return prop.FromAfter(self.Item);
-				case Terminal<TPk>.Older self:
+				case Terminal<TPk, TPKh>.Older self:
 					if (self.Item == 0)
 					{
-						throw new TypeCheckException<TPk>(fragment, ErrorKind.ZeroTime);
+						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroTime);
 					}
 
 					return prop.FromOlder(self.Item);
-				case Terminal<TPk>.Sha256 self:
+				case Terminal<TPk, TPKh>.Sha256 self:
 					return prop.FromSha256();
-				case Terminal<TPk>.Hash256 self:
+				case Terminal<TPk, TPKh>.Hash256 self:
 					return prop.FromHash256();
-				case Terminal<TPk>.Ripemd160 self:
+				case Terminal<TPk, TPKh>.Ripemd160 self:
 					return prop.FromRipemd160();
-				case Terminal<TPk>.Alt self:
+				case Terminal<TPk, TPKh>.Alt self:
 					return GetChild(self.Item.Node, 0).CastAlt();
-				case Terminal<TPk>.Swap self:
+				case Terminal<TPk, TPKh>.Swap self:
 					return GetChild(self.Item.Node, 0).CastSwap();
-				case Terminal<TPk>.Check self:
+				case Terminal<TPk, TPKh>.Check self:
 					return GetChild(self.Item.Node, 0).CastCheck();
-				case Terminal<TPk>.DupIf self:
+				case Terminal<TPk, TPKh>.DupIf self:
 					return GetChild(self.Item.Node, 0).CastDupIf();
-				case Terminal<TPk>.Verify self:
+				case Terminal<TPk, TPKh>.Verify self:
 					return GetChild(self.Item.Node, 0).CastVerify();
-				case Terminal<TPk>.NonZero self:
+				case Terminal<TPk, TPKh>.NonZero self:
 					return GetChild(self.Item.Node, 0).CastNonZero();
-				case Terminal<TPk>.AndB self:
+				case Terminal<TPk, TPKh>.AndB self:
 					var andBL = GetChild(self.Item1.Node, 0);
 					var andBR = GetChild(self.Item2.Node, 1);
 					return prop.AndB(andBL, andBR);
-				case Terminal<TPk>.AndV self:
+				case Terminal<TPk, TPKh>.AndV self:
 					var andVL = GetChild(self.Item1.Node, 0);
 					var andVR = GetChild(self.Item2.Node, 1);
 					return prop.AndV(andVL, andVR);
-				case Terminal<TPk>.OrB self:
+				case Terminal<TPk, TPKh>.OrB self:
 					var orBL = GetChild(self.Item1.Node, 0);
 					var orBR = GetChild(self.Item2.Node, 1);
 					return prop.OrB(orBL, orBR);
-				case Terminal<TPk>.OrD self:
+				case Terminal<TPk, TPKh>.OrD self:
 					var orDL = GetChild(self.Item1.Node, 0);
 					var orDR = GetChild(self.Item2.Node, 1);
 					return prop.OrD(orDL, orDR);
-				case Terminal<TPk>.OrC self:
+				case Terminal<TPk, TPKh>.OrC self:
 					var orCL = GetChild(self.Item1.Node, 0);
 					var orCR = GetChild(self.Item2.Node, 1);
 					return prop.OrC(orCL, orCR);
-				case Terminal<TPk>.OrI self:
+				case Terminal<TPk, TPKh>.OrI self:
 					var orIL = GetChild(self.Item1.Node, 0);
 					var orIR = GetChild(self.Item2.Node, 1);
 					return prop.OrC(orIL, orIR);
-				case Terminal<TPk>.AndOr self:
+				case Terminal<TPk, TPKh>.AndOr self:
 					var a = GetChild(self.Item1.Node, 0);
 					var b = GetChild(self.Item2.Node, 1);
 					var c = GetChild(self.Item3.Node, 2);
 					return prop.AndOr(a, b, c);
-				case Terminal<TPk>.Thresh self:
+				case Terminal<TPk, TPKh>.Thresh self:
 					if (self.Item1 == 0)
 					{
-						throw new TypeCheckException<TPk>(fragment, ErrorKind.ZeroThreshold);
+						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroThreshold);
 					}
 
 					if (self.Item1 > self.Item2.Length)
 					{
-						throw new TypeCheckException<TPk>(fragment, ErrorKind.OverThreshold);
+						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.OverThreshold);
 					}
 					return
 						prop.Threshold(self.Item1, self.Item2.Length, (n) =>
diff --git a/NBitcoin/Scripting/Miniscript/Types/Property.cs b/NBitcoin/Scripting/Miniscript/Types/Property.cs
new file mode 100644
index 0000000000..1599754ee9
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/Property.cs
@@ -0,0 +1,30 @@
+using System;
+
+namespace NBitcoin.Scripting.Miniscript.Types
+{
+	internal static class Property<T> where T : class, IProperty<T>
+	{
+		internal static void SanityChecks(T item)
+		{
+			item.SanityChecks();
+		}
+
+		internal static T FromTrue()
+		{
+			T t = default;
+			return t.FromTrue();
+		}
+
+		internal static T TypeCheck<TPk>(Terminal<TPk, TPK> fragment, Func<int, T> c)
+		where TPk : IMiniscriptKey
+		{
+			T t = default;
+			return t.TypeCheck(fragment, c);
+		}
+		internal static T CastCheck()
+		{
+			T t = default;
+			return t.CastCheck();
+		}
+	}
+}
diff --git a/NBitcoin/UInt2561.cs b/NBitcoin/UInt2561.cs
index 2f1b4ef4b7..bfc58b481d 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,14 @@ public override int GetHashCode()
 			}
 			return hash;
 		}
+
+		public uint160 ToHash160() => this;
+
+		public string ToHex() => ToString();
+
+		public bool TryParse(string str)
+		{
+			return uint160.TryParse(str, out this);
+		}
 	}
 }

From 216ea37bcd3424f1ff15547042589bd4df5cb91d Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Thu, 31 Oct 2019 14:34:42 +0900
Subject: [PATCH 05/50] Chane TypeCheck functionality to static

---
 NBitcoin/Scripting/Miniscript/Miniscript.cs   |  13 +-
 .../Scripting/Miniscript/Policy/Compiler.cs   |  32 ++--
 .../Scripting/Miniscript/Types/IProperty.cs   | 151 ----------------
 .../Miniscript/Types/Malleability.cs          |   2 +
 .../Types/MiniscriptFragmentType.cs           | 102 +++++------
 .../Scripting/Miniscript/Types/Property.cs    | 168 ++++++++++++++++--
 6 files changed, 231 insertions(+), 237 deletions(-)

diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index cb23dbbf06..201614858c 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -25,26 +25,21 @@ internal Miniscript(MiniscriptFragmentType type, Terminal<TPk, TPKh> node, ExtDa
 
 		public static Miniscript<TPk, TPKh> FromAst(Terminal<TPk, TPKh> t)
 		{
-			MiniscriptFragmentType ty = default;
-			ExtData ext = default;
-
 			return
 				new Miniscript<TPk, TPKh>(
-					ty.TypeCheck(t, (_) => null),
+					Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(t),
 					t,
-					ext.TypeCheck(t, (_) => null)
+					Property<ExtData, TPk, TPKh>.TypeCheck(t)
 				);
 		}
 
 		public static Miniscript<TPk, TPKh> Parse(string str)
 		{
 			var inner = MiniscriptDSLParser<TPk, TPKh>.ParseTerminal(str);
-			MiniscriptFragmentType ty = default;
-			ExtData ext = default;
 			return new Miniscript<TPk, TPKh>(
-				ty.TypeCheck(inner),
+				Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(inner),
 				inner,
-				ext.TypeCheck(inner)
+				Property<ExtData, TPk, TPKh>.TypeCheck(inner)
 				);
 		}
 
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index 5cb3cd3da1..037c8fd066 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -70,6 +70,16 @@ internal class CompilerExtData : IProperty<CompilerExtData>
 		/// </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 void SanityChecks()
 		{
 			throw new NotImplementedException();
@@ -273,22 +283,17 @@ internal double Cost1d(double satProb, double? dissatProb)
 
 		internal static AstElemExt<TPk, TPKh> Terminal(Terminal<TPk, TPKh> ast)
 		{
-			CompilerExtData compExtData = default;
-			Miniscript<TPk, TPKh> ms = default;
-			return new AstElemExt<TPk, TPKh>(compExtData.TypeCheck(ast), Miniscript<TPk, TPKh>.FromAst(ast));
+			return new AstElemExt<TPk, TPKh>(Property<CompilerExtData, TPk, TPKh>.TypeCheck(ast), Miniscript<TPk, TPKh>.FromAst(ast));
 		}
 
 		internal static AstElemExt<TPk, TPKh> Binary(Terminal<TPk, TPKh> ast, AstElemExt<TPk, TPKh> l, AstElemExt<TPk, TPKh> r)
 		{
-			MiniscriptFragmentType ty = default;
-			ty = ty.TypeCheck(ast);
-			ExtData ext = default;
-			ext = ext.TypeCheck(ast);
+			var ty = Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(ast);
+			var ext = Property<ExtData, TPk, TPKh>.TypeCheck(ast);
 
 			Func<int, CompilerExtData> lookupExt =
 				(int n) => n == 0 ? l.CompExtData : n == 1 ? r.CompExtData : throw new Exception("Unreachable");
-			CompilerExtData compExtData = default;
-			compExtData = compExtData.TypeCheck(ast, lookupExt);
+			var compExtData = Property<CompilerExtData, TPk, TPKh>.TypeCheck(ast, lookupExt);
 
 			return new AstElemExt<TPk, TPKh>(compExtData, new Miniscript<TPk, TPKh>(ty, ast, ext));
 		}
@@ -307,12 +312,9 @@ AstElemExt<TPk, TPKh> c
 					n == 2 ? c.CompExtData :
 					throw new Exception("Unreachable");
 
-			MiniscriptFragmentType ty = default;
-			ty = ty.TypeCheck(ast);
-			ExtData ext = default;
-			ext = ext.TypeCheck(ast);
-			CompilerExtData compilerExtData = default;
-			compilerExtData = compilerExtData.TypeCheck(ast, lookupExt);
+			var ty = Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(ast);
+			var ext = Property<ExtData, TPk, TPKh>.TypeCheck(ast);
+			var compilerExtData = Property<CompilerExtData, TPk, TPKh>.TypeCheck(ast, lookupExt);
 
 			return new AstElemExt<TPk, TPKh>(compilerExtData, new Miniscript<TPk, TPKh>(ty, ast, ext));
 		}
diff --git a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
index 1a60a7b297..44d0a46de4 100644
--- a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
@@ -160,155 +160,4 @@ public TypeCheckException(string msg): base(msg) {}
 		public TypeCheckException(string msg, Exception innerException): base(msg, innerException) {}
 	}
 
-	public static class PropertyExtensions
-	{
-		/// <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>
-		/// <param name="prop"></param>
-		/// <param name="fragment"></param>
-		/// <param name="child"></param>
-		/// <typeparam name="T"></typeparam>
-		/// <exception cref="TypeCheckException"></exception>
-		/// <returns></returns>
-		internal static T TypeCheck<T, TPk, TPKh>(this T prop, Terminal<TPk, TPKh> fragment, Func<int, T> child)
-			where T : class, IProperty<T>
-			where TPk : IMiniscriptKey<TPKh>
-			where TPKh : IMiniscriptKeyHash
-		{
-			var res = prop.TypeCheckCore(fragment, child);
-			res.SanityChecks();
-			return res;
-		}
-
-		internal static T TypeCheck<T, TPk, TPKh>(this T prop, Terminal<TPk, TPKh> fragment)
-			where T : class, IProperty<T>
-			where TPk : IMiniscriptKey<TPKh>
-			where TPKh : IMiniscriptKeyHash
-			=> prop.TypeCheck(fragment, (_) => null);
-
-		private static T TypeCheckCore<T, TPk, TPKh>(this T prop, Terminal<TPk, TPKh> fragment,Func<int, T> child)
-			where T : class, IProperty<T>
-			where TPk : IMiniscriptKey<TPKh>
-			where TPKh : IMiniscriptKeyHash
-		{
-			T GetChild(Terminal<TPk, TPKh> sub, int n)
-				{
-					try
-					{
-						return child(n);
-					}
-					catch
-					{
-						return prop.TypeCheck(sub, _ => null);
-					}
-				}
-			switch (fragment.Tag)
-			{
-				case Terminal<TPk, TPKh>.Tags.True:
-					return prop.FromTrue();
-				case Terminal<TPk, TPKh>.Tags.False:
-					return prop.FromFalse();
-			}
-
-			switch (fragment)
-			{
-				case Terminal<TPk, TPKh>.Pk self:
-					return prop.FromPk();
-				case Terminal<TPk, TPKh>.PkH self:
-					return prop.FromPkH();
-				case Terminal<TPk, TPKh>.ThreshM self:
-					if (self.Item1 == 0)
-					{
-						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroThreshold);
-					}
-
-					if (self.Item1 > self.Item2.Length)
-					{
-						throw new TypeCheckException<TPk, TPKh>(
-							fragment,
-							ErrorKind.OverThreshold,
-							new int[] {self.Item1, self.Item2.Length});
-					}
-					return prop.FromMulti(self.Item1, self.Item2.Length);
-				case Terminal<TPk, TPKh>.After self:
-					if (self.Item == 0)
-					{
-						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroTime);
-					}
-
-					return prop.FromAfter(self.Item);
-				case Terminal<TPk, TPKh>.Older self:
-					if (self.Item == 0)
-					{
-						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroTime);
-					}
-
-					return prop.FromOlder(self.Item);
-				case Terminal<TPk, TPKh>.Sha256 self:
-					return prop.FromSha256();
-				case Terminal<TPk, TPKh>.Hash256 self:
-					return prop.FromHash256();
-				case Terminal<TPk, TPKh>.Ripemd160 self:
-					return prop.FromRipemd160();
-				case Terminal<TPk, TPKh>.Alt self:
-					return GetChild(self.Item.Node, 0).CastAlt();
-				case Terminal<TPk, TPKh>.Swap self:
-					return GetChild(self.Item.Node, 0).CastSwap();
-				case Terminal<TPk, TPKh>.Check self:
-					return GetChild(self.Item.Node, 0).CastCheck();
-				case Terminal<TPk, TPKh>.DupIf self:
-					return GetChild(self.Item.Node, 0).CastDupIf();
-				case Terminal<TPk, TPKh>.Verify self:
-					return GetChild(self.Item.Node, 0).CastVerify();
-				case Terminal<TPk, TPKh>.NonZero self:
-					return GetChild(self.Item.Node, 0).CastNonZero();
-				case Terminal<TPk, TPKh>.AndB self:
-					var andBL = GetChild(self.Item1.Node, 0);
-					var andBR = GetChild(self.Item2.Node, 1);
-					return prop.AndB(andBL, andBR);
-				case Terminal<TPk, TPKh>.AndV self:
-					var andVL = GetChild(self.Item1.Node, 0);
-					var andVR = GetChild(self.Item2.Node, 1);
-					return prop.AndV(andVL, andVR);
-				case Terminal<TPk, TPKh>.OrB self:
-					var orBL = GetChild(self.Item1.Node, 0);
-					var orBR = GetChild(self.Item2.Node, 1);
-					return prop.OrB(orBL, orBR);
-				case Terminal<TPk, TPKh>.OrD self:
-					var orDL = GetChild(self.Item1.Node, 0);
-					var orDR = GetChild(self.Item2.Node, 1);
-					return prop.OrD(orDL, orDR);
-				case Terminal<TPk, TPKh>.OrC self:
-					var orCL = GetChild(self.Item1.Node, 0);
-					var orCR = GetChild(self.Item2.Node, 1);
-					return prop.OrC(orCL, orCR);
-				case Terminal<TPk, TPKh>.OrI self:
-					var orIL = GetChild(self.Item1.Node, 0);
-					var orIR = GetChild(self.Item2.Node, 1);
-					return prop.OrC(orIL, orIR);
-				case Terminal<TPk, TPKh>.AndOr self:
-					var a = GetChild(self.Item1.Node, 0);
-					var b = GetChild(self.Item2.Node, 1);
-					var c = GetChild(self.Item3.Node, 2);
-					return prop.AndOr(a, b, c);
-				case Terminal<TPk, TPKh>.Thresh self:
-					if (self.Item1 == 0)
-					{
-						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroThreshold);
-					}
-
-					if (self.Item1 > self.Item2.Length)
-					{
-						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.OverThreshold);
-					}
-					return
-						prop.Threshold(self.Item1, self.Item2.Length, (n) =>
-							GetChild(self.Item2[n].Node, (int)n));
-			}
-			throw new Exception("Unreachable!");;
-		}
-	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
index 42ad7b7328..bbabea9f46 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -52,6 +52,8 @@ public Malleability(Dissat dissat, bool safe, bool nonMalleable)
 			NonMalleable = nonMalleable;
 		}
 
+		public Malleability() {}
+
 		internal bool IsSubtype(Malleability other) =>
 			Dissat.IsSubType(other.Dissat) &&
 				other.Safe &&
diff --git a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
index 6132fa5a8d..8e533248cf 100644
--- a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
@@ -18,6 +18,8 @@ private MiniscriptFragmentType(Correctness correctness, Malleability malleabilit
 			Malleability = malleability;
 		}
 
+		public MiniscriptFragmentType() {}
+
 		public bool IsSubtype(MiniscriptFragmentType other) =>
 			this.Correctness.IsSubtype(other.Correctness) &&
 			this.Malleability.IsSubtype(other.Malleability);
@@ -32,43 +34,43 @@ public void SanityChecks()
 
 		public MiniscriptFragmentType FromTrue()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(cor.FromTrue(), mal.FromTrue());
 		}
 
 		public MiniscriptFragmentType FromFalse()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(cor.FromFalse(), mal.FromFalse());
 		}
 
 		public MiniscriptFragmentType FromPk()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(cor.FromPk(), mal.FromPk());
 		}
 
 		public MiniscriptFragmentType FromPkH()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(cor.FromPkH(), mal.FromPkH());
 		}
 
 		public MiniscriptFragmentType FromMulti(int k, int pkLength)
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(cor.FromMulti(k, pkLength), mal.FromMulti(k, pkLength));
 		}
 
 		public MiniscriptFragmentType FromAfter(uint time)
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.FromAfter(time),
 				mal.FromAfter(time));
@@ -76,8 +78,8 @@ public MiniscriptFragmentType FromAfter(uint time)
 
 		public MiniscriptFragmentType FromOlder(uint time)
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.FromOlder(time),
 				mal.FromOlder(time));
@@ -86,8 +88,8 @@ public MiniscriptFragmentType FromOlder(uint time)
 		public MiniscriptFragmentType FromHash()
 		{
 
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.FromHash(),
 				mal.FromHash());
@@ -95,8 +97,8 @@ public MiniscriptFragmentType FromHash()
 
 		public MiniscriptFragmentType FromSha256()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.FromSha256(),
 				mal.FromSha256());
@@ -104,8 +106,8 @@ public MiniscriptFragmentType FromSha256()
 
 		public MiniscriptFragmentType FromHash256()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.FromHash256(),
 				mal.FromHash256());
@@ -113,8 +115,8 @@ public MiniscriptFragmentType FromHash256()
 
 		public MiniscriptFragmentType FromRipemd160()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.FromRipemd160(),
 				mal.FromRipemd160());
@@ -122,8 +124,8 @@ public MiniscriptFragmentType FromRipemd160()
 
 		public MiniscriptFragmentType FromHash160()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.FromHash160(),
 				mal.FromHash160());
@@ -131,8 +133,8 @@ public MiniscriptFragmentType FromHash160()
 
 		public MiniscriptFragmentType CastAlt()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.CastAlt(),
 				mal.CastAlt());
@@ -140,8 +142,8 @@ public MiniscriptFragmentType CastAlt()
 
 		public MiniscriptFragmentType CastSwap()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.CastSwap(),
 				mal.CastSwap());
@@ -149,8 +151,8 @@ public MiniscriptFragmentType CastSwap()
 
 		public MiniscriptFragmentType CastCheck()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.CastCheck(),
 				mal.CastCheck());
@@ -158,8 +160,8 @@ public MiniscriptFragmentType CastCheck()
 
 		public MiniscriptFragmentType CastDupIf()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.CastDupIf(),
 				mal.CastDupIf());
@@ -167,8 +169,8 @@ public MiniscriptFragmentType CastDupIf()
 
 		public MiniscriptFragmentType CastVerify()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.CastVerify(),
 				mal.CastVerify());
@@ -176,8 +178,8 @@ public MiniscriptFragmentType CastVerify()
 
 		public MiniscriptFragmentType CastNonZero()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.CastNonZero(),
 				mal.CastNonZero());
@@ -185,8 +187,8 @@ public MiniscriptFragmentType CastNonZero()
 
 		public MiniscriptFragmentType CastZeroNotEqual()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.CastZeroNotEqual(),
 				mal.CastZeroNotEqual());
@@ -194,8 +196,8 @@ public MiniscriptFragmentType CastZeroNotEqual()
 
 		public MiniscriptFragmentType CastTrue()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.CastTrue(),
 				mal.CastTrue());
@@ -203,8 +205,8 @@ public MiniscriptFragmentType CastTrue()
 
 		public MiniscriptFragmentType CastOrIFalse()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.CastOrIFalse(),
 				mal.CastOrIFalse());
@@ -212,8 +214,8 @@ public MiniscriptFragmentType CastOrIFalse()
 
 		public MiniscriptFragmentType CastUnLikely()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.CastUnLikely(),
 				mal.CastUnLikely());
@@ -221,8 +223,8 @@ public MiniscriptFragmentType CastUnLikely()
 
 		public MiniscriptFragmentType CastLikely()
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.CastLikely(),
 				mal.CastLikely());
@@ -230,8 +232,8 @@ public MiniscriptFragmentType CastLikely()
 
 		public MiniscriptFragmentType AndB(MiniscriptFragmentType left, MiniscriptFragmentType right)
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.AndB(left.Correctness, right.Correctness),
 				mal.AndB(left.Malleability, right.Malleability));
@@ -239,8 +241,8 @@ public MiniscriptFragmentType AndB(MiniscriptFragmentType left, MiniscriptFragme
 
 		public MiniscriptFragmentType AndV(MiniscriptFragmentType left, MiniscriptFragmentType right)
 		{
-			Correctness cor = default;
-			Malleability mal = default;
+			var cor = new Correctness();
+			var mal = new Malleability();
 			return new MiniscriptFragmentType(
 				cor.AndV(left.Correctness, right.Correctness),
 				mal.AndV(left.Malleability, right.Malleability));
diff --git a/NBitcoin/Scripting/Miniscript/Types/Property.cs b/NBitcoin/Scripting/Miniscript/Types/Property.cs
index 1599754ee9..1ad55b99c1 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Property.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Property.cs
@@ -1,30 +1,174 @@
 using System;
+using NBitcoin.Scripting.Miniscript.Policy;
 
 namespace NBitcoin.Scripting.Miniscript.Types
 {
-	internal static class Property<T> where T : class, IProperty<T>
+	public static class Property<T, TPk, TPKh>
+	where T : class, IProperty<T>, new()
+	where TPk : IMiniscriptKey<TPKh>
+	where TPKh : IMiniscriptKeyHash
 	{
+		/*
 		internal static void SanityChecks(T item)
 		{
-			item.SanityChecks();
+			if (item is Correctness correctness)
+				throw new NotImplementedException();
+
+			// no check for default.
+		}
+
+		internal static T FromTrue(T item)
+		{
+			if (item is CompilerExtData compilerExtData)
+				throw new NotSupportedException("Unreachable");
 		}
 
-		internal static T FromTrue()
+		internal static IProperty<T> FromFalse(T item)
 		{
-			T t = default;
-			return t.FromTrue();
+			if (item is CompilerExtData compilerExtData)
+				return new CompilerExtData(null, double.MaxValue, 0.0);
 		}
+		*/
+
 
-		internal static T TypeCheck<TPk>(Terminal<TPk, TPK> fragment, Func<int, T> c)
-		where TPk : IMiniscriptKey
+		/// <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>
+		/// <param name="prop"></param>
+		/// <param name="fragment"></param>
+		/// <param name="child"></param>
+		/// <typeparam name="T"></typeparam>
+		/// <exception cref="TypeCheckException"></exception>
+		/// <returns></returns>
+		internal static T TypeCheck(Terminal<TPk, TPKh> fragment, Func<int, T> child)
 		{
-			T t = default;
-			return t.TypeCheck(fragment, c);
+			var res = TypeCheckCore(fragment, child);
+			res.SanityChecks();
+			return res;
 		}
-		internal static T CastCheck()
+
+		internal static T TypeCheck(Terminal<TPk, TPKh> fragment)
+			=> TypeCheck(fragment, (_) => null);
+
+		private static T TypeCheckCore(Terminal<TPk, TPKh> fragment,Func<int, T> child)
 		{
-			T t = default;
-			return t.CastCheck();
+			T GetChild(Terminal<TPk, TPKh> sub, int n)
+				{
+					try
+					{
+						return child(n);
+					}
+					catch
+					{
+						return TypeCheck(sub, _ => null);
+					}
+				}
+			switch (fragment.Tag)
+			{
+				case Terminal<TPk, TPKh>.Tags.True:
+					return new T().FromTrue();
+				case Terminal<TPk, TPKh>.Tags.False:
+					return new T().FromFalse();
+			}
+
+			switch (fragment)
+			{
+				case Terminal<TPk, TPKh>.Pk self:
+					return new T().FromPk();
+				case Terminal<TPk, TPKh>.PkH self:
+					return new T().FromPkH();
+				case Terminal<TPk, TPKh>.ThreshM self:
+					if (self.Item1 == 0)
+					{
+						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroThreshold);
+					}
+
+					if (self.Item1 > self.Item2.Length)
+					{
+						throw new TypeCheckException<TPk, TPKh>(
+							fragment,
+							ErrorKind.OverThreshold,
+							new int[] {(int)self.Item1, self.Item2.Length});
+					}
+					return new T().FromMulti((int)self.Item1, self.Item2.Length);
+				case Terminal<TPk, TPKh>.After self:
+					if (self.Item == 0)
+					{
+						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroTime);
+					}
+
+					return new T().FromAfter(self.Item);
+				case Terminal<TPk, TPKh>.Older self:
+					if (self.Item == 0)
+					{
+						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroTime);
+					}
+
+					return new T().FromOlder(self.Item);
+				case Terminal<TPk, TPKh>.Sha256 self:
+					return new T().FromSha256();
+				case Terminal<TPk, TPKh>.Hash256 self:
+					return new T().FromHash256();
+				case Terminal<TPk, TPKh>.Ripemd160 self:
+					return new T().FromRipemd160();
+				case Terminal<TPk, TPKh>.Alt self:
+					return GetChild(self.Item.Node, 0).CastAlt();
+				case Terminal<TPk, TPKh>.Swap self:
+					return GetChild(self.Item.Node, 0).CastSwap();
+				case Terminal<TPk, TPKh>.Check self:
+					return GetChild(self.Item.Node, 0).CastCheck();
+				case Terminal<TPk, TPKh>.DupIf self:
+					return GetChild(self.Item.Node, 0).CastDupIf();
+				case Terminal<TPk, TPKh>.Verify self:
+					return GetChild(self.Item.Node, 0).CastVerify();
+				case Terminal<TPk, TPKh>.NonZero self:
+					return GetChild(self.Item.Node, 0).CastNonZero();
+				case Terminal<TPk, TPKh>.AndB self:
+					var andBL = GetChild(self.Item1.Node, 0);
+					var andBR = GetChild(self.Item2.Node, 1);
+					return new T().AndB(andBL, andBR);
+				case Terminal<TPk, TPKh>.AndV self:
+					var andVL = GetChild(self.Item1.Node, 0);
+					var andVR = GetChild(self.Item2.Node, 1);
+					return new T().AndV(andVL, andVR);
+				case Terminal<TPk, TPKh>.OrB self:
+					var orBL = GetChild(self.Item1.Node, 0);
+					var orBR = GetChild(self.Item2.Node, 1);
+					return new T().OrB(orBL, orBR);
+				case Terminal<TPk, TPKh>.OrD self:
+					var orDL = GetChild(self.Item1.Node, 0);
+					var orDR = GetChild(self.Item2.Node, 1);
+					return new T().OrD(orDL, orDR);
+				case Terminal<TPk, TPKh>.OrC self:
+					var orCL = GetChild(self.Item1.Node, 0);
+					var orCR = GetChild(self.Item2.Node, 1);
+					return new T().OrC(orCL, orCR);
+				case Terminal<TPk, TPKh>.OrI self:
+					var orIL = GetChild(self.Item1.Node, 0);
+					var orIR = GetChild(self.Item2.Node, 1);
+					return new T().OrC(orIL, orIR);
+				case Terminal<TPk, TPKh>.AndOr self:
+					var a = GetChild(self.Item1.Node, 0);
+					var b = GetChild(self.Item2.Node, 1);
+					var c = GetChild(self.Item3.Node, 2);
+					return new T().AndOr(a, b, c);
+				case Terminal<TPk, TPKh>.Thresh self:
+					if (self.Item1 == 0)
+					{
+						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroThreshold);
+					}
+
+					if (self.Item1 > self.Item2.Length)
+					{
+						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.OverThreshold);
+					}
+					return
+						new T().Threshold((int)self.Item1, self.Item2.Length, (n) =>
+							GetChild(self.Item2[n].Node, (int)n));
+			}
+			throw new Exception("Unreachable!");;
 		}
 	}
 }

From 6186ed46c54d2453c815f9684d35e1acbcb7701a Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Thu, 31 Oct 2019 16:13:50 +0900
Subject: [PATCH 06/50] Fix compile error

---
 NBitcoin.Tests/MiniscriptTests.cs             | 14 +--
 NBitcoin/KeyId.cs                             |  2 +-
 NBitcoin/PubKey.cs                            | 26 +++---
 NBitcoin/Scripting/Miniscript/AstElem.cs      |  4 +-
 NBitcoin/Scripting/Miniscript/ILiftable.cs    |  8 +-
 NBitcoin/Scripting/Miniscript/Miniscript.cs   |  4 +-
 .../MiniscriptDSLParser.Terminal.cs           |  6 +-
 .../MiniscriptDSLParsers.ConcretePolicy.cs    | 24 ++++--
 .../Scripting/Miniscript/MiniscriptKey.cs     | 85 ++++++++++++++++++-
 .../Miniscript/MiniscriptScriptParser.cs      |  2 +-
 .../Scripting/Miniscript/Policy/Compiler.cs   | 12 +--
 .../Scripting/Miniscript/Types/IProperty.cs   |  4 +-
 .../Scripting/Miniscript/Types/Property.cs    | 10 +--
 NBitcoin/UInt2561.cs                          |  4 -
 14 files changed, 142 insertions(+), 63 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 64a5204254..3b512152fe 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -170,19 +170,19 @@ public static class MiniscriptTests
 		[Trait("Core", "Core")]
 		public static void MiniscriptAttributesTest(
 			string msStr, string expectedHex, bool valid, bool nonMalleable,
-			bool needSig, uint ops)
+			bool needSig, uint ops, uint _stack)
 		{
 			if (valid)
 			{
-				var ms = Miniscript<PubKey>.Parse(msStr);
-				Assert.Equal(ms.Encode().ToHex(), expectedHex);
-				Assert.Equal(ms.Type.Malleability.NonMalleable, nonMalleable);
-				Assert.Equal(ms.Type.Malleability.Safe, needSig);
-				Assert.Equal(ms.Ext.OpsCountSat, ops);
+				var ms = Miniscript<PubKey, uint160>.Parse(msStr);
+				// Assert.Equal(ms.ToScript().ToHex(), expectedHex);
+				// Assert.Equal(ms.Type.Malleability.NonMalleable, nonMalleable);
+				// Assert.Equal(ms.Type.Malleability.Safe, needSig);
+				// Assert.Equal(ms.Ext.OpsCountSat, ops);
 			}
 			else
 			{
-				Assert.Throws<ParsingException>(() => Miniscript<PubKey>.Parse(msStr));
+				Assert.Throws<ParsingException>(() => Miniscript<PubKey, uint160>.Parse(msStr));
 			}
 		}
 	}
diff --git a/NBitcoin/KeyId.cs b/NBitcoin/KeyId.cs
index 6556b87013..e273530b72 100644
--- a/NBitcoin/KeyId.cs
+++ b/NBitcoin/KeyId.cs
@@ -86,7 +86,7 @@ public override string ToString()
 			return _Str;
 		}
 	}
-	public class KeyId : TxDestination , IMiniscriptKeyHash
+	public class KeyId : TxDestination
 	{
 		public KeyId()
 			: this(0)
diff --git a/NBitcoin/PubKey.cs b/NBitcoin/PubKey.cs
index 7ccb841e8f..b048ece0e0 100644
--- a/NBitcoin/PubKey.cs
+++ b/NBitcoin/PubKey.cs
@@ -6,7 +6,6 @@
 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;
@@ -42,6 +41,8 @@ public PubKey(string hex)
 
 		}
 
+		public PubKey() {}
+
 		/// <summary>
 		/// Create a new Public key from byte array
 		/// </summary>
@@ -50,27 +51,22 @@ public PubKey(byte[] bytes)
 		{
 		}
 
-		public bool TryParse(string hex)
+		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;
-			vch = v;
 			try
 			{
-				_ECKey = new ECKey(v, false);
+				result = new PubKey(v);
+				return true;
 			}
-			catch (Exception ex)
+			catch
 			{
-				throw new FormatException("Invalid public key", ex);
+				return true;
 			}
-			return true;
-		}
-
-		public bool Equals(IMiniscriptKey<uint160> other)
-		{
-			throw new NotImplementedException();
 		}
 
 		/// <summary>
@@ -263,6 +259,11 @@ public string ToHex()
 			return Encoders.Hex.EncodeData(vch);
 		}
 
+		public bool Equals(IMiniscriptKey<uint160> other)
+		{
+			throw new NotImplementedException();
+		}
+
 		#region IBitcoinSerializable Members
 
 		public void ReadWrite(BitcoinStream stream)
@@ -581,7 +582,6 @@ public BitcoinWitPubKeyAddress GetSegwitAddress(Network network)
 
 		#endregion
 
-		public IMiniscriptKeyHash MiniscriptKeyHash => Hash;
 		public uint160 ToPubKeyHash()
 		{
 			throw new NotImplementedException();
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index b5b77241b0..67e8594cd5 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -92,8 +92,8 @@ public bool Equals(NonTerm other)
 	}
 
 	public partial class Terminal<TPk, TPKh> : IEquatable<Terminal<TPk, TPKh>>
-		where TPk : IMiniscriptKey<TPKh>
-		where TPKh : IMiniscriptKeyHash
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		# region Subtype definitions
 		internal static class Tags
diff --git a/NBitcoin/Scripting/Miniscript/ILiftable.cs b/NBitcoin/Scripting/Miniscript/ILiftable.cs
index 9ec63ac4c1..697a3bdeca 100644
--- a/NBitcoin/Scripting/Miniscript/ILiftable.cs
+++ b/NBitcoin/Scripting/Miniscript/ILiftable.cs
@@ -13,16 +13,16 @@ public interface ILiftable<TPk, TPKh>
 	}
 
 	public partial class Miniscript<TPk, TPKh> : ILiftable<TPk, TPKh>
-		where TPk : IMiniscriptKey<TPKh>
-		where TPKh : IMiniscriptKeyHash
+		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 : IMiniscriptKey<TPKh>
-		where TPKh : IMiniscriptKeyHash
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		public AbstractPolicy<TPk, TPKh> Lift()
 		{
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index 201614858c..8136a86baf 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -4,8 +4,8 @@
 namespace NBitcoin.Scripting.Miniscript
 {
 	public partial class Miniscript<TPk, TPKh>
-		where TPk : IMiniscriptKey<TPKh>
-		where TPKh : IMiniscriptKeyHash
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		internal readonly Terminal<TPk, TPKh> Node;
 		public readonly MiniscriptFragmentType Type;
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
index 3be0196317..ce1da4ec71 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
@@ -6,8 +6,8 @@
 namespace NBitcoin.Scripting.Miniscript
 {
 	internal static partial class MiniscriptDSLParser<TPk, TPKh>
-		where TPk : IMiniscriptKey<TPKh>
-		where TPKh : IMiniscriptKeyHash
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		# region Leaf
 		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalPk
@@ -54,7 +54,7 @@ private static Parser<char, Terminal<TPk, TPKh>> PWrapper(char identifier,
 			Func<Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> construct)
 			=>
 				from _t in Parse.Char(identifier).Then(_ => Parse.Char(':'))
-				from inner in TerminalDSLParser
+				from inner in Parse.Ref(() => TerminalDSLParser)
 					.Except(PWrapper(identifier, construct)) // should not have same wrapper twice
 				select construct(Miniscript<TPk, TPKh>.FromAst(inner));
 
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
index 02acb359b0..05d095ae56 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
@@ -11,8 +11,8 @@
 namespace NBitcoin.Scripting.Miniscript
 {
 	internal static partial class MiniscriptDSLParser<TPk, TPKh>
-			where TPk : IMiniscriptKey<TPKh>
-			where TPKh : IMiniscriptKeyHash
+			where TPk : class, IMiniscriptKey<TPKh>, new()
+			where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		internal static readonly Parser<char, string> SurroundedByBrackets  =
 				from leftB in Parse.Char('(').Token()
@@ -85,18 +85,30 @@ internal static Parser<char, TPk> TryParseMiniscriptKey(string str)
 			=> i =>
 			{
 				TPk t = default;
-				if (!t.TryParse(str))
+				try
+				{
+					var k = MiniscriptKeyParser<TPk, TPKh>.TryParse(str);
 					return ParserResult<char, TPk>.Failure(i, $"Failed to parse MiniscriptKey {str}");
-				return ParserResult<char, TPk>.Success(i, t);
+				}
+				catch
+				{
+					return ParserResult<char, TPk>.Success(i, t);
+				}
 			};
 
 		internal static Parser<char, TPKh> TryParseMiniscriptKeyHash(string str)
 			=> i =>
 			{
 				TPKh t = default;
-				if (!t.TryParse(str))
+				try
+				{
+					var k = MiniscriptKeyParser<TPk, TPKh>.TryParseHash(str);
+					return ParserResult<char, TPKh>.Success(i, t);
+				}
+				catch
+				{
 					return ParserResult<char, TPKh>.Failure(i, "");
-				return ParserResult<char, TPKh>.Success(i, t);
+				}
 			};
 
 		internal static Parser<char, string> ExprP(string name)
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
index d8ce0f1eb9..594ed9e18f 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
@@ -6,7 +6,6 @@ public interface IMiniscriptKeyHash
 	{
 		uint160 ToHash160();
 		string ToHex();
-		bool TryParse(string str);
 	}
 
 	/// <summary>
@@ -15,7 +14,8 @@ public interface IMiniscriptKeyHash
 	/// 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
+	public interface IMiniscriptKey<TPKh>
+		where TPKh : IMiniscriptKeyHash
 	{
 		TPKh ToPubKeyHash();
 
@@ -34,9 +34,86 @@ public interface IMiniscriptKey<TPKh> where TPKh : IMiniscriptKeyHash
 
 		string ToHex();
 
-		bool TryParse(string str);
-
 		bool Equals(IMiniscriptKey<TPKh> other);
 	}
 
+	public class MiniscriptStringKeyHash : IMiniscriptKeyHash
+	{
+		public uint160 ToHash160()
+		{
+			throw new NotImplementedException();
+		}
+
+		public string ToHex()
+		{
+			throw new NotImplementedException();
+		}
+
+		public static MiniscriptStringKeyHash Parse(string str)
+		{
+			throw new NotImplementedException();
+		}
+	}
+	public class MiniscriptStringKey : IMiniscriptKey<MiniscriptStringKeyHash>
+	{
+		public MiniscriptStringKeyHash ToPubKeyHash()
+		{
+			throw new NotImplementedException();
+		}
+
+		public PubKey ToPublicKey()
+		{
+			throw new NotImplementedException();
+		}
+
+		public int SerializedLength()
+		{
+			throw new NotImplementedException();
+		}
+
+		public string ToHex()
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool Equals(IMiniscriptKey<MiniscriptStringKeyHash> other)
+		{
+			throw new NotImplementedException();
+		}
+
+		public static MiniscriptStringKey Parse(string str)
+		{
+			throw new NotImplementedException();
+		}
+	}
+	public static class MiniscriptKeyParser<T, TPKh>
+		where TPKh : class, IMiniscriptKeyHash, new()
+		where T : class, IMiniscriptKey<TPKh>, new()
+	{
+		public static T TryParse(string str)
+		{
+			var t = new T();
+			if (t is PubKey)
+			{
+				return new PubKey(str) as T;
+			}
+
+			if (t is MiniscriptStringKey)
+			{
+				return MiniscriptStringKey.Parse(str) as T;
+			}
+			throw new NotSupportedException();
+		}
+
+		public static TPKh TryParseHash(string str)
+		{
+			var t = new TPKh();
+			if (t is uint160)
+				return uint160.Parse(str) as TPKh;
+			if (t is MiniscriptStringKeyHash)
+				return MiniscriptStringKeyHash.Parse(str) as TPKh;
+			throw new NotSupportedException();
+		}
+	}
+
 }
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs b/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
index a87d2f641a..858531720d 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptScriptParser.cs
@@ -387,7 +387,6 @@ private static P PostProcess(AstElem ast)
 
 		public static AstElem ParseScript(Script sc)
 			=> PT.Parse(sc);
-		*/
 
 
 		public static Terminal<TPk, TPKh> ParseScript<TPk, TPKh>(Script sc)
@@ -455,5 +454,6 @@ public static Miniscript<TPk, TPKh> ParseScriptToken<TPk, TPKh>(ScriptToken sct)
 			}
 			throw new NotImplementedException();
 		}
+		*/
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index 037c8fd066..0bceb85c9b 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -247,8 +247,8 @@ public CompilerExtData Threshold(int k, int n, Func<uint, CompilerExtData> subCk
 	}
 
 	internal class AstElemExt<TPk, TPKh>
-		where TPk : IMiniscriptKey<TPKh>
-		where TPKh : IMiniscriptKeyHash
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		internal readonly Miniscript<TPk, TPKh> Ms;
 		internal readonly CompilerExtData CompExtData;
@@ -321,8 +321,8 @@ AstElemExt<TPk, TPKh> c
 	}
 
 	internal class Cast<TPk, TPKh>
-		where TPk : IMiniscriptKey<TPKh>
-		where TPKh : IMiniscriptKeyHash
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		public Func<Terminal<TPk, TPKh>> Node;
 		public Func<MiniscriptFragmentType> AstType;
@@ -415,8 +415,8 @@ public static List<Cast<TPk, TPKh>> GetAllCasts(AstElemExt<TPk, TPKh> ast)
 	}
 
 	public static class Compiler<TPk, TPKh>
-		where TPk : IMiniscriptKey<TPKh>
-		where TPKh : IMiniscriptKeyHash
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		private static void InsertElem(
 			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> map,
diff --git a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
index 44d0a46de4..e05dfa492b 100644
--- a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
@@ -137,8 +137,8 @@ public enum ErrorKind
 	}
 
 	class TypeCheckException<TPk, TPKh> : Exception
-		where TPk : IMiniscriptKey<TPKh>
-		where TPKh : IMiniscriptKeyHash
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		public readonly Terminal<TPk, TPKh> Fragment;
 		public readonly ErrorKind Kind;
diff --git a/NBitcoin/Scripting/Miniscript/Types/Property.cs b/NBitcoin/Scripting/Miniscript/Types/Property.cs
index 1ad55b99c1..67ca29afa3 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Property.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Property.cs
@@ -5,8 +5,8 @@ namespace NBitcoin.Scripting.Miniscript.Types
 {
 	public static class Property<T, TPk, TPKh>
 	where T : class, IProperty<T>, new()
-	where TPk : IMiniscriptKey<TPKh>
-	where TPKh : IMiniscriptKeyHash
+	where TPk : class, IMiniscriptKey<TPKh>, new()
+	where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		/*
 		internal static void SanityChecks(T item)
@@ -36,12 +36,6 @@ internal static IProperty<T> FromFalse(T item)
 		/// the types of its children, if available and relevant for the
 		/// given fragment.
 		/// </summary>
-		/// <param name="prop"></param>
-		/// <param name="fragment"></param>
-		/// <param name="child"></param>
-		/// <typeparam name="T"></typeparam>
-		/// <exception cref="TypeCheckException"></exception>
-		/// <returns></returns>
 		internal static T TypeCheck(Terminal<TPk, TPKh> fragment, Func<int, T> child)
 		{
 			var res = TypeCheckCore(fragment, child);
diff --git a/NBitcoin/UInt2561.cs b/NBitcoin/UInt2561.cs
index bfc58b481d..ab377bf7c0 100644
--- a/NBitcoin/UInt2561.cs
+++ b/NBitcoin/UInt2561.cs
@@ -857,9 +857,5 @@ public override int GetHashCode()
 
 		public string ToHex() => ToString();
 
-		public bool TryParse(string str)
-		{
-			return uint160.TryParse(str, out this);
-		}
 	}
 }

From a88edc623764eca41ca3762d77a607269a375cf5 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Fri, 1 Nov 2019 00:37:18 +0900
Subject: [PATCH 07/50] redefine every Parser Combinator as function so that we
 can easily find recursion bug

---
 NBitcoin.Tests/MiniscriptTests.cs             | 12 ++-
 .../MiniscriptDSLParser.Terminal.cs           | 22 ++---
 .../MiniscriptDSLParsers.ConcretePolicy.cs    | 95 +++++++++----------
 .../Miniscript/Policy/ConcretePolicy.cs       |  9 +-
 4 files changed, 72 insertions(+), 66 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 3b512152fe..37d42dd421 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -1,11 +1,12 @@
 using System;
 using NBitcoin.Scripting.Miniscript;
+using NBitcoin.Scripting.Miniscript.Policy;
 using NBitcoin.Scripting.Parser;
 using Xunit;
 
 namespace NBitcoin.Tests
 {
-	public static class MiniscriptTests
+	public class MiniscriptTests
 	{
 		public static readonly TheoryData<string, string, bool, bool, bool, uint, uint> MSAttributeTestCase =
 			new TheoryData<string, string, bool, bool, bool, uint, uint>()
@@ -168,7 +169,7 @@ public static class MiniscriptTests
 		[Theory]
 		[MemberData(nameof(MSAttributeTestCase))]
 		[Trait("Core", "Core")]
-		public static void MiniscriptAttributesTest(
+		public void MiniscriptAttributesTest(
 			string msStr, string expectedHex, bool valid, bool nonMalleable,
 			bool needSig, uint ops, uint _stack)
 		{
@@ -185,5 +186,12 @@ public static void MiniscriptAttributesTest(
 				Assert.Throws<ParsingException>(() => Miniscript<PubKey, uint160>.Parse(msStr));
 			}
 		}
+
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void MiniscriptUnitTest()
+		{
+			var ms = ConcretePolicy<MiniscriptStringKey, MiniscriptStringKeyHash>.Parse("pk()");
+		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
index ce1da4ec71..8526373197 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
@@ -91,14 +91,14 @@ select constructor(
 
 		private static readonly Parser<char, Terminal<TPk, TPKh>> TerminalDSLParser =
 			// ------ leafs ------
-			PTerminalPk
-				.Or(PTerminalPkH)
-				.Or(PTerminalAfter)
-				.Or(PTerminalOlder)
-				.Or(PTerminalSha256)
-				.Or(PTerminalHash256)
-				.Or(PTerminalRipemd160)
-				.Or(PTerminalHash160)
+			Parse.Ref(() => PTerminalPk)
+				.Or(Parse.Ref(() => PTerminalPkH))
+				.Or(Parse.Ref(() => PTerminalAfter))
+				.Or(Parse.Ref(() => PTerminalOlder))
+				.Or(Parse.Ref(() => PTerminalSha256))
+				.Or(Parse.Ref(() => PTerminalHash256))
+				.Or(Parse.Ref(() => PTerminalRipemd160))
+				.Or(Parse.Ref(() => PTerminalHash160))
 				// ------- wrappers --------
 				.Or(PWrapper('a', Terminal<TPk, TPKh>.NewAlt))
 				.Or(PWrapper('s', Terminal<TPk, TPKh>.NewSwap))
@@ -116,10 +116,10 @@ select constructor(
 				.Or(PBinary("or_c", Terminal<TPk, TPKh>.NewOrC))
 				.Or(PBinary("or_i", Terminal<TPk, TPKh>.NewOrI))
 				// ------- Thresholds ------
-				.Or(PTerminalThresh)
-				.Or(PTerminalThreshM);
+				.Or(Parse.Ref(() => PTerminalThresh))
+				.Or(Parse.Ref(() => PTerminalThreshM));
 
 		public static Terminal<TPk, TPKh> ParseTerminal(string input)
-			=> TerminalDSLParser.Parse(input);
+			=> Parse.Ref(() => TerminalDSLParser).Parse(input);
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
index 05d095ae56..8fa4ae0619 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
@@ -14,7 +14,7 @@ internal static partial class MiniscriptDSLParser<TPk, TPKh>
 			where TPk : class, IMiniscriptKey<TPKh>, new()
 			where TPKh : class, IMiniscriptKeyHash, new()
 	{
-		internal static readonly Parser<char, string> SurroundedByBrackets  =
+		internal static Parser<char, string> SurroundedByBrackets()  =>
 				from leftB in Parse.Char('(').Token()
 				from x in Parse.CharExcept(')').Many().Text()
 				from rightB in Parse.Char(')').Token()
@@ -88,11 +88,11 @@ internal static Parser<char, TPk> TryParseMiniscriptKey(string str)
 				try
 				{
 					var k = MiniscriptKeyParser<TPk, TPKh>.TryParse(str);
-					return ParserResult<char, TPk>.Failure(i, $"Failed to parse MiniscriptKey {str}");
+					return ParserResult<char, TPk>.Success(i, k);
 				}
-				catch
+				catch (Exception ex)
 				{
-					return ParserResult<char, TPk>.Success(i, t);
+					return ParserResult<char, TPk>.Failure(i, $"Failed to parse MiniscriptKey {str}. {ex}");
 				}
 			};
 
@@ -114,7 +114,7 @@ internal static Parser<char, TPKh> TryParseMiniscriptKeyHash(string str)
 		internal static Parser<char, string> ExprP(string name)
 			=>
 			from identifier in Parse.String(name)
-			from x in SurroundedByBrackets
+			from x in SurroundedByBrackets()
 			select x;
 
 		private static Parser<char, string[]> ExprPMany(string name)
@@ -122,38 +122,38 @@ private static Parser<char, string[]> ExprPMany(string name)
 			from x in ExprP(name)
 			select SafeSplit(x);
 
-		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PPubKeyExpr
-			=
+		private static Parser<char, ConcretePolicy<TPk, TPKh>> PPubKeyExpr()
+			=>
 			from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
 			select ConcretePolicy<TPk, TPKh>.NewKey(pk);
 
-		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PSha256Expr
-			=
+		private static Parser<char, ConcretePolicy<TPk, TPKh>> PSha256Expr()
+			=>
 			from hash in ExprP("sha256").Then(s => TryConvert(s, uint256.Parse))
 			select ConcretePolicy<TPk, TPKh>.NewSha256(hash);
 
-		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PHash256Expr
-			=
+		private static Parser<char, ConcretePolicy<TPk, TPKh>> PHash256Expr()
+			=>
 			from hash in ExprP("hash256").Then(s => TryConvert(s, uint256.Parse))
 			select ConcretePolicy<TPk, TPKh>.NewHash256(hash);
 
-		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PRipemd160Expr
-			=
+		private static Parser<char, ConcretePolicy<TPk, TPKh>> PRipemd160Expr()
+			=>
 			from hash in ExprP("ripemd160").Then(s => TryConvert(s, uint160.Parse))
 			select ConcretePolicy<TPk, TPKh>.NewRipemd160(hash);
 
-		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PHash160Expr
-			=
+		private static Parser<char, ConcretePolicy<TPk, TPKh>> PHash160Expr()
+			=>
 			from hash in ExprP("hash160").Then(s => TryConvert(s, uint160.Parse))
 			select ConcretePolicy<TPk, TPKh>.NewHash160(hash);
 
-		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PAfterExpr
-			=
+		private static Parser<char, ConcretePolicy<TPk, TPKh>> PAfterExpr()
+			=>
 			from t in ExprP("after").Then(s => TryConvert(s, UInt32.Parse))
 			select ConcretePolicy<TPk, TPKh>.NewAfter(t);
 
-		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> POlderExpr
-			=
+		private static Parser<char, ConcretePolicy<TPk, TPKh>> POlderExpr()
+			=>
 			from t in ExprP("older").Then(s => TryConvert(s, UInt32.Parse))
 			select ConcretePolicy<TPk, TPKh>.NewOlder(t);
 
@@ -166,29 +166,29 @@ from x in Parse
 			from _right in Parse.Char(')')
 			select x;
 
-		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PAndExpr
-			=
-			from x in PSubExprs("and", DSLParser)
+		private static Parser<char, ConcretePolicy<TPk, TPKh>> PAndExpr()
+			=>
+			from x in PSubExprs("and", DSLParser())
 			select ConcretePolicy<TPk, TPKh>.NewAnd(x);
 
-		private static readonly Parser<char, Tuple<uint, ConcretePolicy<TPk, TPKh>>> POrWithProb
-			=
+		private static Parser<char, Tuple<uint, ConcretePolicy<TPk, TPKh>>> POrWithProb()
+			=>
 			from x in Parse.Digit.AtLeastOnce().Text()
 				.Then(digitStr => TryConvert(digitStr, UInt32.Parse))
 			from _a in Parse.Char('@')
-			from sub in Parse.Ref(() => DSLParser)
+			from sub in Parse.Ref(() => DSLParser())
 			select Tuple.Create(x, sub);
 
-		private static readonly Parser<char, Tuple<uint, ConcretePolicy<TPk, TPKh>>> POrWithoutProb
-			=
-			from sub in Parse.Ref(() => DSLParser)
+		private static Parser<char, Tuple<uint, ConcretePolicy<TPk, TPKh>>> POrWithoutProb()
+			=>
+			from sub in Parse.Ref(() => DSLParser())
 			select Tuple.Create(1U, sub);
 
-		private static readonly Parser<char, ConcretePolicy<TPk, TPKh>> POrExpr
-			=
+		private static Parser<char, ConcretePolicy<TPk, TPKh>> POrExpr()
+			=>
 			from x in
-				PSubExprs("or", POrWithProb)
-				.Or(PSubExprs("or", POrWithoutProb))
+				PSubExprs("or", POrWithProb())
+				.Or(PSubExprs("or", POrWithoutProb()))
 			select ConcretePolicy<TPk, TPKh>.NewOr(x);
 
 		private static Parser<char, T> PThresh<T, TIn>(
@@ -208,23 +208,22 @@ from _right in Parse.Char(')')
 			where num <= x.Count()
 			select constructor(num, x);
 
-		internal static readonly Parser<char, ConcretePolicy<TPk, TPKh>> PThresholdExpr =
-			PThresh("thresh", ConcretePolicy<TPk, TPKh>.NewThreshold, DSLParser);
-
-		internal static readonly Parser<char, ConcretePolicy<TPk, TPKh>> DSLParser
-			=
-			(PPubKeyExpr
-				.Or(PAfterExpr)
-				.Or(POlderExpr)
-				.Or(PSha256Expr)
-				.Or(PHash256Expr)
-				.Or(PRipemd160Expr)
-				.Or(PHash160Expr)
-				.Or(PAndExpr)
-				.Or(POrExpr)
-				.Or(PThresholdExpr)).Token();
+		internal static Parser<char, ConcretePolicy<TPk, TPKh>> PThresholdExpr() =>
+			PThresh("thresh", ConcretePolicy<TPk, TPKh>.NewThreshold, DSLParser());
+
+		internal static Parser<char, ConcretePolicy<TPk, TPKh>> DSLParser() =>
+			(PPubKeyExpr())
+				.Or(PAfterExpr())
+				.Or(POlderExpr()
+				.Or(PSha256Expr())
+				.Or(PHash256Expr())
+				.Or(PRipemd160Expr())
+				.Or(PHash160Expr())
+				.Or(PAndExpr())
+				.Or(POrExpr())
+				.Or(PThresholdExpr())).Token();
 
 		public static ConcretePolicy<TPk, TPKh> ParseConcretePolicy(string input)
-			=> DSLParser.Parse(input);
+			=> DSLParser().Parse(input);
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
index 759aecae15..42508e3c7e 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
@@ -33,8 +33,8 @@ public enum PolicyError
 		TimeTooFar
 	}
 	public class ConcretePolicy<TPk, TPKh> : IEquatable<ConcretePolicy<TPk, TPKh>>, ILiftable<TPk, TPKh>
-		where TPk : IMiniscriptKey<TPKh>
-		where TPKh : IMiniscriptKeyHash
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		#region Subtype definitions
 
@@ -452,10 +452,9 @@ private StringBuilder ToStringCore(StringBuilder sb)
 			throw new Exception("Unreachable!");
 		}
 
-		public static ConcretePolicy<TPk, TPKh> FromTree()
+		public static ConcretePolicy<TPk, TPKh> Parse(string str)
 		{
-
-			throw new NotImplementedException("");
+			return MiniscriptDSLParser<TPk, TPKh>.ParseConcretePolicy(str);
 		}
 
 		private static Tuple<uint, ConcretePolicy<TPk, TPKh>> FromTreeProb<T>(Tree<T> top, bool allowProb)

From 168dd09539220ad2cc76d7eb5462a8f0b215375d Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sun, 3 Nov 2019 00:14:12 +0900
Subject: [PATCH 08/50] Update MiniscriptKey

---
 .../Scripting/Miniscript/MiniscriptKey.cs     | 44 ++++++++++---------
 1 file changed, 24 insertions(+), 20 deletions(-)

diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
index 594ed9e18f..2ffb884569 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
@@ -39,52 +39,56 @@ public interface IMiniscriptKey<TPKh>
 
 	public class MiniscriptStringKeyHash : IMiniscriptKeyHash
 	{
-		public uint160 ToHash160()
-		{
-			throw new NotImplementedException();
-		}
+		public readonly string Text;
+		public MiniscriptStringKeyHash() {}
 
-		public string ToHex()
+		public MiniscriptStringKeyHash(string text)
 		{
-			throw new NotImplementedException();
+			Text = text;
 		}
 
-		public static MiniscriptStringKeyHash Parse(string str)
+		public uint160 ToHash160()
 		{
-			throw new NotImplementedException();
+			throw new NotSupportedException();
 		}
+
+		public string ToHex() => Text;
+
+		public static MiniscriptStringKeyHash Parse(string str) => new MiniscriptStringKeyHash(str);
 	}
 	public class MiniscriptStringKey : IMiniscriptKey<MiniscriptStringKeyHash>
 	{
-		public MiniscriptStringKeyHash ToPubKeyHash()
+		public readonly string Text;
+
+		public MiniscriptStringKey() {}
+		public MiniscriptStringKey(string text)
 		{
-			throw new NotImplementedException();
+			Text = text;
 		}
 
+		public MiniscriptStringKeyHash ToPubKeyHash() =>
+			new MiniscriptStringKeyHash($"<{Text}>");
+
 		public PubKey ToPublicKey()
 		{
-			throw new NotImplementedException();
+			throw new NotSupportedException();
 		}
 
 		public int SerializedLength()
 		{
-			throw new NotImplementedException();
+			throw new NotSupportedException();
 		}
 
-		public string ToHex()
-		{
-			throw new NotImplementedException();
-		}
+		public string ToHex() => Text;
 
 		public bool Equals(IMiniscriptKey<MiniscriptStringKeyHash> other)
 		{
-			throw new NotImplementedException();
+			return Equals(other as MiniscriptStringKey);
 		}
 
+
 		public static MiniscriptStringKey Parse(string str)
-		{
-			throw new NotImplementedException();
-		}
+			=> new MiniscriptStringKey(str);
 	}
 	public static class MiniscriptKeyParser<T, TPKh>
 		where TPKh : class, IMiniscriptKeyHash, new()

From 692a97768ec30715cf48d19bbb484f39df856d17 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sun, 3 Nov 2019 14:37:19 +0900
Subject: [PATCH 09/50] Fix StackOVerflow bug when parsing ConcretePolicy

---
 NBitcoin.Tests/MiniscriptTests.cs             | 18 +++++-
 NBitcoin/Scripting/Miniscript/Input.cs        |  8 ++-
 .../Scripting/Miniscript/InputExtensions.cs   |  4 +-
 .../MiniscriptDSLParser.Terminal.cs           |  8 +--
 .../MiniscriptDSLParsers.ConcretePolicy.cs    | 25 +++-----
 .../Scripting/Miniscript/Types/Correctness.cs | 63 ++++++++++---------
 .../Types/MiniscriptFragmentType.cs           |  2 +-
 7 files changed, 73 insertions(+), 55 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 37d42dd421..1594d6cdcd 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -1,4 +1,5 @@
 using System;
+using NBitcoin.DataEncoders;
 using NBitcoin.Scripting.Miniscript;
 using NBitcoin.Scripting.Miniscript.Policy;
 using NBitcoin.Scripting.Parser;
@@ -8,6 +9,7 @@ namespace NBitcoin.Tests
 {
 	public class MiniscriptTests
 	{
+		public static HexEncoder Hex = new DataEncoders.HexEncoder();
 		public static readonly TheoryData<string, string, bool, bool, bool, uint, uint> MSAttributeTestCase =
 			new TheoryData<string, string, bool, bool, bool, uint, uint>()
 			{
@@ -189,9 +191,21 @@ public void MiniscriptAttributesTest(
 
 		[Fact]
 		[Trait("UnitTest", "UnitTest")]
-		public void MiniscriptUnitTest()
+		public void PolicyParserTest()
 		{
-			var ms = ConcretePolicy<MiniscriptStringKey, MiniscriptStringKeyHash>.Parse("pk()");
+			ConcretePolicy<MiniscriptStringKey, MiniscriptStringKeyHash>.Parse("pk(foo)");
+
+			var pk = new Key(Hex.DecodeData("4141414141414141414141414141414141414141414141414141414141414141")).PubKey;
+			Assert.Throws<ParsingException>(() => ConcretePolicy<PubKey, uint160>.Parse("pk(foo)"));
+			var msRealPK = ConcretePolicy<PubKey, uint160>.Parse($"pk({pk})");
+			Assert.True(msRealPK.IsValid());
+		}
+
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void MiniscriptParserTest()
+		{
+			var ms = Miniscript<PubKey, uint160>.Parse();
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Input.cs b/NBitcoin/Scripting/Miniscript/Input.cs
index f9b72e4f2f..8ed0cca25d 100644
--- a/NBitcoin/Scripting/Miniscript/Input.cs
+++ b/NBitcoin/Scripting/Miniscript/Input.cs
@@ -1,11 +1,15 @@
 namespace NBitcoin.Scripting.Miniscript
 {
+	/// <summary>
+	/// Type property representing exceptions about how many inputs
+	/// the fragment accepts, and assumptions about that.
+	/// </summary>
 	public enum Input
 	{
 		Zero,
 		One,
 		Any,
-		OneNoneZero,
+		OneNonZero,
 		AnyNonZero
 	}
-}
\ No newline at end of file
+}
diff --git a/NBitcoin/Scripting/Miniscript/InputExtensions.cs b/NBitcoin/Scripting/Miniscript/InputExtensions.cs
index 02f3a94fb3..85dce15a06 100644
--- a/NBitcoin/Scripting/Miniscript/InputExtensions.cs
+++ b/NBitcoin/Scripting/Miniscript/InputExtensions.cs
@@ -7,10 +7,10 @@ public static bool IsSubtype(this Input self, Input other)
 			if (self == other)
 				return true;
 
-			if (self == Input.OneNoneZero && other == Input.One)
+			if (self == Input.OneNonZero && other == Input.One)
 				return true;
 
-			if (self == Input.OneNoneZero && other == Input.AnyNonZero)
+			if (self == Input.OneNonZero && other == Input.AnyNonZero)
 				return true;
 
 			if (other == Input.Any)
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
index 8526373197..d3ac459bfb 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
@@ -62,7 +62,7 @@ private static Parser<char, Terminal<TPk, TPKh>> PBinary(
 			string identifier,
 			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> constructor
 		) =>
-			from s in PSubExprs(identifier, TerminalDSLParser)
+			from s in PSubExprs(identifier, () => TerminalDSLParser)
 			where s.Count() == 2
 			select constructor(Miniscript<TPk, TPKh>.FromAst(s.ElementAt(0)),
 				Miniscript<TPk, TPKh>.FromAst(s.ElementAt(1)));
@@ -71,7 +71,7 @@ private static Parser<char, Terminal<TPk, TPKh>> PTernary(
 			string identifier,
 			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> constructor
 		) =>
-			from s in PSubExprs(identifier, TerminalDSLParser)
+			from s in PSubExprs(identifier, () => TerminalDSLParser)
 			where s.Count() == 3
 			select constructor(
 				Miniscript<TPk, TPKh>.FromAst(s.ElementAt(0)),
@@ -82,11 +82,11 @@ select constructor(
 			PThresh(
 				"thresh",
 				Terminal<TPk, TPKh>.NewThresh,
-				TerminalDSLParser.Select(t => Miniscript<TPk, TPKh>.FromAst(t)));
+				() => TerminalDSLParser.Select(t => Miniscript<TPk, TPKh>.FromAst(t)));
 
 		private static Parser<char, Terminal<TPk, TPKh>> PTerminalThreshM =
 			PThresh("thresh_m", Terminal<TPk, TPKh>.NewThreshM,
-			(from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
+			() => (from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
 			select pk));
 
 		private static readonly Parser<char, Terminal<TPk, TPKh>> TerminalDSLParser =
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
index 8fa4ae0619..bf11f3d751 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
@@ -117,11 +117,6 @@ from identifier in Parse.String(name)
 			from x in SurroundedByBrackets()
 			select x;
 
-		private static Parser<char, string[]> ExprPMany(string name)
-			=>
-			from x in ExprP(name)
-			select SafeSplit(x);
-
 		private static Parser<char, ConcretePolicy<TPk, TPKh>> PPubKeyExpr()
 			=>
 			from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
@@ -157,18 +152,18 @@ private static Parser<char, ConcretePolicy<TPk, TPKh>> POlderExpr()
 			from t in ExprP("older").Then(s => TryConvert(s, UInt32.Parse))
 			select ConcretePolicy<TPk, TPKh>.NewOlder(t);
 
-		private static Parser<char, IEnumerable<TSub>> PSubExprs<TSub>(string name, Parser<char, TSub> subP) =>
+		private static Parser<char, IEnumerable<TSub>> PSubExprs<TSub>(string name, Func<Parser<char, TSub>> subP) =>
 			from _n in Parse.String(name)
 			from _left in Parse.Char('(')
 			from x in Parse
-				.Ref(() => subP)
+				.Ref(subP)
 				.DelimitedBy(Parse.Char(',').Token()).Token()
 			from _right in Parse.Char(')')
 			select x;
 
 		private static Parser<char, ConcretePolicy<TPk, TPKh>> PAndExpr()
 			=>
-			from x in PSubExprs("and", DSLParser())
+			from x in PSubExprs("and", DSLParser)
 			select ConcretePolicy<TPk, TPKh>.NewAnd(x);
 
 		private static Parser<char, Tuple<uint, ConcretePolicy<TPk, TPKh>>> POrWithProb()
@@ -187,14 +182,14 @@ from sub in Parse.Ref(() => DSLParser())
 		private static Parser<char, ConcretePolicy<TPk, TPKh>> POrExpr()
 			=>
 			from x in
-				PSubExprs("or", POrWithProb())
-				.Or(PSubExprs("or", POrWithoutProb()))
+				PSubExprs("or", POrWithProb)
+				.Or(PSubExprs("or", POrWithoutProb))
 			select ConcretePolicy<TPk, TPKh>.NewOr(x);
 
 		private static Parser<char, T> PThresh<T, TIn>(
 			string identifier,
 			Func<uint, IEnumerable<TIn>, T> constructor,
-			Parser<char, TIn> subP
+			Func<Parser<char, TIn>> subP
 			) =>
 			from _n in Parse.String(identifier)
 			from _left in Parse.Char('(')
@@ -202,19 +197,19 @@ from numStr in Parse.Digit.AtLeastOnce().Text()
 			from _sep in Parse.Char(',')
 			from num in TryConvert(numStr, UInt32.Parse)
 			from x in Parse
-				.Ref(() => subP)
+				.Ref(subP)
 				.DelimitedBy(Parse.Char(',').Token()).Token()
 			from _right in Parse.Char(')')
 			where num <= x.Count()
 			select constructor(num, x);
 
 		internal static Parser<char, ConcretePolicy<TPk, TPKh>> PThresholdExpr() =>
-			PThresh("thresh", ConcretePolicy<TPk, TPKh>.NewThreshold, DSLParser());
+			PThresh("thresh", ConcretePolicy<TPk, TPKh>.NewThreshold, DSLParser);
 
 		internal static Parser<char, ConcretePolicy<TPk, TPKh>> DSLParser() =>
 			(PPubKeyExpr())
-				.Or(PAfterExpr())
-				.Or(POlderExpr()
+			.Or(PAfterExpr())
+			.Or(POlderExpr()
 				.Or(PSha256Expr())
 				.Or(PHash256Expr())
 				.Or(PRipemd160Expr())
diff --git a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
index bb6026ce30..521dd1a080 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
@@ -1,19 +1,28 @@
 using System;
+using System.Diagnostics;
 using NBitcoin.Scripting.Miniscript.Policy;
 
 namespace NBitcoin.Scripting.Miniscript.Types
 {
-	public class Correctness : IProperty<Correctness>
+	internal class Correctness : IProperty<Correctness>
 	{
-		public Base Base;
-		public Input Input;
-		public bool DisSatisfiable;
+		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(Base @base, Input input, bool disSatisfiable, bool unit)
+		{
+			Base = @base;
+			Input = input;
+			DisSatisfiable = disSatisfiable;
+			Unit = unit;
+		}
+
 		public bool IsSubtype(Correctness other) =>
 			(this.Base == other.Base) &&
 			(this.Input.IsSubtype(other.Input)) &&
@@ -22,48 +31,44 @@ public bool IsSubtype(Correctness other) =>
 
 		public void SanityChecks()
 		{
-			throw new NotImplementedException();
+			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 Correctness FromTrue()
-		{
-			throw new NotImplementedException();
-		}
+			=> new Correctness(Base.B, Input.Zero, false, true);
 
 		public Correctness FromFalse()
-		{
-			throw new NotImplementedException();
-		}
+			=> new Correctness(Base.B, Input.Zero, true, false);
 
 		public Correctness FromPk()
-		{
-			throw new NotImplementedException();
-		}
+			=> new Correctness(Base.K, Input.OneNonZero, true, true);
 
 		public Correctness FromPkH()
-		{
-			throw new NotImplementedException();
-		}
+			=> new Correctness(Base.K, Input.AnyNonZero, true, true);
 
 		public Correctness FromMulti(int k, int pkLength)
-		{
-			throw new NotImplementedException();
-		}
+			=> new Correctness(Base.B, Input.AnyNonZero, true, true);
 
 		public Correctness FromAfter(uint time)
-		{
-			throw new NotImplementedException();
-		}
+			=> new Correctness(Base.B, Input.Zero, false, false);
 
 		public Correctness FromOlder(uint time)
-		{
-			throw new NotImplementedException();
-		}
+			=> new Correctness(Base.B, Input.Zero, false, false);
 
 		public Correctness FromHash()
-		{
-			throw new NotImplementedException();
-		}
+			=> new Correctness(Base.B, Input.OneNonZero, true, true);
 
 		public Correctness FromSha256()
 		{
diff --git a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
index 8e533248cf..5d128b8e59 100644
--- a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
@@ -8,7 +8,7 @@ namespace NBitcoin.Scripting.Miniscript.Types
 {
 	public class MiniscriptFragmentType : IProperty<MiniscriptFragmentType>
 	{
-		public readonly Correctness Correctness;
+		internal readonly Correctness Correctness;
 
 		internal readonly Malleability Malleability;
 

From 58ec205e9c7b564e85635b418058a9edc78435a3 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Tue, 5 Nov 2019 20:34:58 +0900
Subject: [PATCH 10/50] Implement Types members and Compilers

---
 NBitcoin/Scripting/Miniscript/AstElem.cs      |  26 +-
 .../Scripting/Miniscript/Policy/Compiler.cs   | 649 ++++++++++++++----
 .../Scripting/Miniscript/Types/Correctness.cs | 333 ++++++---
 .../Scripting/Miniscript/Types/ExtData.cs     | 587 +++++++++++-----
 .../Scripting/Miniscript/Types/IProperty.cs   | 190 +++--
 .../Miniscript/Types/Malleability.cs          | 280 ++++----
 .../Types/MiniscriptFragmentType.cs           | 440 +++++-------
 .../Scripting/Miniscript/Types/Property.cs    |  24 +-
 NBitcoin/Scripting/Miniscript/Utils.cs        |  22 +
 9 files changed, 1625 insertions(+), 926 deletions(-)
 create mode 100644 NBitcoin/Scripting/Miniscript/Utils.cs

diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 67e8594cd5..5cd21d73bf 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -595,22 +595,6 @@ private List<Op> ToOpList()
 			throw new Exception(("Unreachable!"));
 		}
 
-		private int ScriptNumSize(int n) => ScriptNumSize((ulong)n);
-		private int ScriptNumSize(ulong n)
-		{
-			if (n <= 0x10) // OP_n
-				return 1;
-			if (n < 0x10) // 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>
-		}
 		public int ScriptSize()
 		{
 			switch (this.Tag)
@@ -628,9 +612,9 @@ public int ScriptSize()
 				case PkH _:
 					return 24;
 				case After self:
-					return ScriptNumSize(self.Item) + 1;
+					return Utils.ScriptNumSize(self.Item) + 1;
 				case Older self:
-					return ScriptNumSize(self.Item) + 1;
+					return Utils.ScriptNumSize(self.Item) + 1;
 				case Sha256 _:
 					return 33 + 6;
 				case Hash256 _:
@@ -677,16 +661,16 @@ public int ScriptSize()
 				case Thresh self:
 					Debug.Assert(self.Item2.Length != 0);
 					return
-						ScriptNumSize(self.Item1) + // k
+						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
-						ScriptNumSize(self.Item1) +
+						Utils.ScriptNumSize(self.Item1) +
 						1 +
-						ScriptNumSize(self.Item2.Length) +
+						Utils.ScriptNumSize(self.Item2.Length) +
 						self.Item2.Select(x => x.SerializedLength()).Sum();
 			}
 
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index 0bceb85c9b..07f508d792 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -1,5 +1,8 @@
 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;
 
@@ -12,6 +15,10 @@ public class CompilerException : Exception
 		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) {}
 	}
 
@@ -42,11 +49,11 @@ internal class CompilationKey
 		internal readonly double? DissatProb;
 
 		public bool IsSubtype(CompilationKey other) =>
-			this.Type.IsSubtype(other.Type) &&
-			this.ExpensiveVerify == other.ExpensiveVerify &&
-			this.DissatProb == other.DissatProb;
+			Type.IsSubtype(other.Type) &&
+			ExpensiveVerify == other.ExpensiveVerify &&
+			DissatProb == other.DissatProb;
 
-		private CompilationKey(MiniscriptFragmentType type, double? dissatProb, bool expensiveVerify)
+		internal CompilationKey(MiniscriptFragmentType type, bool expensiveVerify, double? dissatProb)
 		{
 			Type = type;
 			DissatProb = dissatProb;
@@ -62,7 +69,7 @@ internal class CompilerExtData : IProperty<CompilerExtData>
 		/// the probability of its branch being taken. Otherwise it is ignored.
 		/// All functions initialize it to `None` .
 		/// </summary>
-		internal readonly double? BranchProb;
+		internal double? BranchProb;
 
 		/// <summary>
 		/// The number of bytes needed to satisfy the fragment in segwit format
@@ -80,169 +87,158 @@ public CompilerExtData(double? branchProb, double satisfyCost, double? dissatCos
 
 		public CompilerExtData() {}
 
-		public void SanityChecks()
+		public override CompilerExtData FromTrue()
 		{
-			throw new NotImplementedException();
+			// only used in casts. should never be computed directly
+			throw new Exception("Unreachable");
 		}
 
-		public CompilerExtData FromTrue()
-		{
-			throw new NotImplementedException();
-		}
-
-		public CompilerExtData FromFalse()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData FromFalse() =>
+			new CompilerExtData(
+				null,
+				double.MaxValue,
+				0.0
+				);
 
-		public CompilerExtData FromPk()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData FromPk() =>
+			new CompilerExtData(
+				null,
+				73.0,
+				1.0
+				);
 
-		public CompilerExtData FromPkH()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData FromPkH() =>
+			new CompilerExtData(null, 73.0 + 34.0, 1.0 + 34.0);
 
-		public CompilerExtData FromMulti(int k, int pkLength)
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData FromMulti(int k, int pkLength) =>
+			new CompilerExtData(null, 1.0 + 73.0 * k, (1.0 * (k + 1)));
 
-		public CompilerExtData FromAfter(uint time)
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData FromHash()
+			=> new CompilerExtData(null, 33.0, 33.0);
 
-		public CompilerExtData FromOlder(uint time)
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData FromTime(uint time) =>
+			new CompilerExtData(null, 0.0, null);
 
-		public CompilerExtData FromHash()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData CastAlt()
+			=> new CompilerExtData(null, SatisfyCost, DissatCost);
 
-		public CompilerExtData FromSha256()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData CastSwap() =>
+			new CompilerExtData(null, SatisfyCost, DissatCost);
 
-		public CompilerExtData FromHash256()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData CastCheck()
+			=> new CompilerExtData(null, SatisfyCost, DissatCost);
 
-		public CompilerExtData FromRipemd160()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData CastDupIf()
+			=> new CompilerExtData(null, 2.0 + SatisfyCost, 1.0);
 
-		public CompilerExtData FromHash160()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData CastVerify()
+			=> new CompilerExtData(null, SatisfyCost, null);
 
-		public CompilerExtData CastAlt()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData CastNonZero()
+			=> new CompilerExtData(null, SatisfyCost, 1.0);
 
-		public CompilerExtData CastSwap()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData CastZeroNotEqual()
+			=> new CompilerExtData(null, SatisfyCost, DissatCost);
 
-		public CompilerExtData CastCheck()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData CastTrue()
+			=> new CompilerExtData(null, SatisfyCost, null);
 
-		public CompilerExtData CastDupIf()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData CastOrIFalse()
+			=> new CompilerExtData(null, SatisfyCost, null);
 
-		public CompilerExtData CastVerify()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData CastUnLikely()
+			=> new CompilerExtData(null, 2.0 + SatisfyCost, 1.0);
 
-		public CompilerExtData CastNonZero()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData CastLikely()
+			=> new CompilerExtData(null, 1.0 + SatisfyCost, 2.0);
 
-		public CompilerExtData CastZeroNotEqual()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData AndB(CompilerExtData l, CompilerExtData r)
+			=> new CompilerExtData(null, l.SatisfyCost + r.SatisfyCost,
+				l.DissatCost + r.DissatCost
+				);
 
-		public CompilerExtData CastTrue()
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData AndV(CompilerExtData l, CompilerExtData r)
+			=> new CompilerExtData(null, l.SatisfyCost + r.SatisfyCost, null);
 
-		public CompilerExtData CastOrIFalse()
+		public override CompilerExtData OrB(CompilerExtData left, CompilerExtData right)
 		{
-			throw new NotImplementedException();
+			var lProb = left.BranchProb.Value; // left branch prob must always be set for disjunctions
+			var rProb = right.BranchProb.Value; // and for right branch.
+			return new CompilerExtData(
+				null,
+				lProb * (left.SatisfyCost + right.DissatCost.Value) + rProb * (right.SatisfyCost + left.DissatCost.Value),
+				left.DissatCost + right.DissatCost
+				);
 		}
 
-		public CompilerExtData CastUnLikely()
+		public override CompilerExtData OrD(CompilerExtData left, CompilerExtData right)
 		{
-			throw new NotImplementedException();
+			var lProb = left.BranchProb.Value; // left branch prob must always be set for disjunctions
+			var rProb = left.BranchProb.Value; // and for right branch.
+			return new CompilerExtData(
+				null,
+				(lProb * left.SatisfyCost + rProb * (right.SatisfyCost + left.DissatCost.Value)),
+				right.DissatCost + left.DissatCost
+				);
 		}
 
-		public CompilerExtData CastLikely()
+		public override CompilerExtData OrC(CompilerExtData left, CompilerExtData right)
 		{
-			throw new NotImplementedException();
+			var lProb = left.BranchProb.Value; // left branch prob must always be set for disjunctions
+			var rProb = right.BranchProb.Value; // and for right branch.
+			return new CompilerExtData(
+				null,
+				lProb * (left.SatisfyCost + right.DissatCost.Value) +
+				rProb * (right.SatisfyCost + left.DissatCost.Value),
+				null
+			);
 		}
 
-		public CompilerExtData AndB(CompilerExtData left, CompilerExtData right)
+		public override CompilerExtData OrI(CompilerExtData left, CompilerExtData right)
 		{
-			throw new NotImplementedException();
+			var lProb = left.BranchProb.Value; // left branch prob must always be set for disjunctions
+			var rProb = right.BranchProb.Value; // and for right branch.
+			return new CompilerExtData(
+				null,
+				lProb * (2.0 + left.SatisfyCost) + rProb * (1.0 + right.SatisfyCost),
+				new[] {(2.0 + left.DissatCost), (1.0 + right.DissatCost)}.Min()
+				);
 		}
 
-		public CompilerExtData AndV(CompilerExtData left, CompilerExtData right)
+		public override CompilerExtData AndOr(CompilerExtData a, CompilerExtData b, CompilerExtData c)
 		{
-			throw new NotImplementedException();
+			if (!a.DissatCost.HasValue) throw CastException.LeftNotDissatisfiable;
+			var aProb = a.BranchProb.Value;
+			var bProb = b.BranchProb.Value;
+			var cProb = c.BranchProb.Value;
+			var aDis = a.DissatCost.Value;
+			return new CompilerExtData(
+				null,
+				aProb * (a.SatisfyCost + b.SatisfyCost)
+				+ cProb * (aDis + c.SatisfyCost),
+				aDis + c.DissatCost
+				);
 		}
 
-		public CompilerExtData AndN(CompilerExtData left, CompilerExtData right)
-		{
-			throw new NotImplementedException();
-		}
+		public override CompilerExtData AndN(CompilerExtData l, CompilerExtData r)
+			=> new CompilerExtData(null, l.SatisfyCost + r.SatisfyCost, l.DissatCost);
 
-		public CompilerExtData OrB(CompilerExtData left, CompilerExtData right)
+		public override CompilerExtData Threshold(int k, int n, Func<int, CompilerExtData> subCk)
 		{
-			throw new NotImplementedException();
-		}
-
-		public CompilerExtData OrD(CompilerExtData left, CompilerExtData right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public CompilerExtData OrC(CompilerExtData left, CompilerExtData right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public CompilerExtData OrI(CompilerExtData left, CompilerExtData right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public CompilerExtData AndOr(CompilerExtData a, CompilerExtData b, CompilerExtData c)
-		{
-			throw new NotImplementedException();
-		}
+			var kOverN = k;
+			var satisfyCost = 0.0;
+			var dissatisfyCost = 0.0;
+			for (int i = 0; i < n; i++)
+			{
+				var sub = subCk(i);
+				satisfyCost += sub.SatisfyCost;
+				dissatisfyCost += sub.DissatCost.Value;
+			}
 
-		public CompilerExtData Threshold(int k, int n, Func<uint, CompilerExtData> subCk)
-		{
-			throw new NotImplementedException();
+			return new CompilerExtData(
+				null,
+				satisfyCost * kOverN + dissatisfyCost * (1.0 - kOverN),
+				dissatisfyCost);
 		}
 	}
 
@@ -275,8 +271,8 @@ internal double Cost1d(double satProb, double? dissatProb)
 			else if (dissatProb.HasValue && !CompExtData.DissatCost.HasValue)
 				dissatCost = double.PositiveInfinity;
 			return
-				(double)this.Ms.Ext.PkCost +
-				(this.CompExtData.SatisfyCost * satProb) +
+				Ms.Ext.PkCost +
+				(CompExtData.SatisfyCost * satProb) +
 				dissatCost;
 
 		}
@@ -340,11 +336,11 @@ public Cast(Func<ExtData> extData, Func<MiniscriptFragmentType> astType, Func<Te
 		public AstElemExt<TPk, TPKh> InvokeCast()
 			=>
 				new AstElemExt<TPk, TPKh>(
-					compilerExtData: this.CompilerExtData.Invoke(),
+					compilerExtData: CompilerExtData.Invoke(),
 					ms: new Miniscript<TPk, TPKh>(
-						this.AstType.Invoke(),
-						this.Node.Invoke(),
-						this.ExtData.Invoke()
+						AstType.Invoke(),
+						Node.Invoke(),
+						ExtData.Invoke()
 
 					));
 
@@ -418,18 +414,131 @@ public static class Compiler<TPk, TPKh>
 		where TPk : class, IMiniscriptKey<TPKh>, new()
 		where TPKh : class, IMiniscriptKeyHash, new()
 	{
-		private static void InsertElem(
+		private static bool InsertElem(
 			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> map,
 			AstElemExt<TPk, TPKh> astElemExt,
-			double SatProb,
+			double satProb,
 			double? dissatProb
 		)
 		{
-			throw new NotImplementedException();
+			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
+			//
+			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.
+				map = map.Where(kv =>
+				{
+					var existingElementsCost = kv.Value.Cost1d(satProb, dissatProb);
+					return !((elemKey.IsSubtype(kv.Key)) && existingElementsCost >= elemCost);
+				}).ToDictionary(kv => kv.Key, kv => kv.Value);
+				map.Add(elemKey, astElemExt);
+			}
+
+			return !isWorse;
 		}
 
 		/// <summary>
-		/// Get teh best compilations of a policy with a given sat and dissat probabilities. This functions
+		/// 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
+		/// </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 Stack<AstElemExt<TPk, TPKh>>();
+			if (InsertElem(map, astElemExt, satProb, dissatProb))
+				castStack.Push(astElemExt);
+
+			while (castStack.Count != 0)
+			{
+				var casts = Cast<TPk, TPKh>.GetAllCasts(castStack.Pop());
+				foreach (var c in casts)
+				{
+					try
+					{
+						var newExt = c.InvokeCast();
+						if (InsertElem(map, newExt, satProb, dissatProb))
+							castStack.Push(newExt);
+					} catch (CastException e) {}
+				}
+			}
+		}
+
+		/// <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 = Cast<TPk, TPKh>.GetAllCasts(x);
+					foreach (var c in casts) {
+						try
+						{
+							var newExt = c.InvokeCast();
+							InsertElemClosure(map, newExt, satProb, dissatProb);
+						}
+						catch (CastException _)
+						{
+						}
+					}
+				}
+			}
+		}
+
+		/// <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>
@@ -437,19 +546,248 @@ private static void InsertElem(
 		/// <param name="satProb"></param>
 		/// <param name="dissatProb"></param>
 		/// <returns></returns>
-		private static IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> BestCompilation(
-			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+		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
 		)
 		{
-			throw new NotImplementedException();
+			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);
+					var astExtResult = new AstElemExt<TPk, TPKh>(
+						new CompilerExtData().Threshold((int)pol.Item1, n, index => subExtData[index]),
+							Miniscript<TPk, TPKh>.FromAst(astResult));
+					insertWrap(astExtResult);
+					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);
+
+			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>, float, float>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
 				policyCache,
 			ConcretePolicy<TPk, TPKh> policy,
 			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> ret,
@@ -461,11 +799,25 @@ private static void CompileBinary(
 			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> binFunc
 		)
 		{
+			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;
+					try
+					{
+						var newExt = AstElemExt<TPk, TPKh>.Binary(ast, l, r);
+						InsertBestWrapped(policyCache, policy, ret, newExt, satProb, dissatProb);
+					} catch (TypeCheckException<TPk, TPKh> ex) {}
+				}
+			}
 			throw new NotImplementedException();
 		}
 
 		private static void CompileTernary(
-			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
 				policyCache,
 			ConcretePolicy<TPk, TPKh> policy,
 			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> ret,
@@ -474,8 +826,7 @@ private static void CompileTernary(
 			IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> cComp,
 			Tuple<double, double> weights,
 			double satProb,
-			double? dissatProb,
-			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> binFunc
+			double? dissatProb
 			)
 		{
 		}
@@ -483,7 +834,7 @@ Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> binFunc
 		public static Miniscript<TPk, TPKh> BestCompilation(ConcretePolicy<TPk, TPKh> policy)
 		{
 			var policyCache =
-				new Dictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>();
+				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;
@@ -494,7 +845,7 @@ public static Miniscript<TPk, TPKh> BestCompilation(ConcretePolicy<TPk, TPKh> po
 		}
 
 		private static AstElemExt<TPk, TPKh> BestT(
-			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
 				policyCache,
 			ConcretePolicy<TPk, TPKh> policy,
 			double satProb,
@@ -505,7 +856,7 @@ private static AstElemExt<TPk, TPKh> BestT(
 		}
 
 		private static AstElemExt<TPk, TPKh> BestE(
-			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
 				policyCache,
 				ConcretePolicy<TPk, TPKh> policy,
 				double satProb,
@@ -516,7 +867,7 @@ private static AstElemExt<TPk, TPKh> BestE(
 		}
 
 		private static AstElemExt<TPk, TPKh> BestW(
-			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, float, float>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
+			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
 				policyCache,
 				ConcretePolicy<TPk, TPKh> policy,
 				double satProb,
diff --git a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
index 521dd1a080..eb378fe58e 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Diagnostics;
-using NBitcoin.Scripting.Miniscript.Policy;
 
 namespace NBitcoin.Scripting.Miniscript.Types
 {
@@ -15,6 +14,8 @@ internal class Correctness : IProperty<Correctness>
 		/// </summary>
 		public bool Unit;
 
+		public Correctness() {}
+
 		public Correctness(Base @base, Input input, bool disSatisfiable, bool unit)
 		{
 			Base = @base;
@@ -29,7 +30,7 @@ public bool IsSubtype(Correctness other) =>
 			(!(!(this.DisSatisfiable) && other.DisSatisfiable)) &&
 			(!(!(this.Unit) && other.Unit));
 
-		public void SanityChecks()
+		public override void SanityChecks()
 		{
 			if (Base == Base.B) return;
 			if (Base == Base.K) Debug.Assert(Unit);
@@ -46,148 +47,256 @@ public void SanityChecks()
 			}
 		}
 
-		public Correctness FromTrue()
+		public override Correctness FromTrue()
 			=> new Correctness(Base.B, Input.Zero, false, true);
 
-		public Correctness FromFalse()
+		public override Correctness FromFalse()
 			=> new Correctness(Base.B, Input.Zero, true, false);
 
-		public Correctness FromPk()
+		public override Correctness FromPk()
 			=> new Correctness(Base.K, Input.OneNonZero, true, true);
 
-		public Correctness FromPkH()
+		public override Correctness FromPkH()
 			=> new Correctness(Base.K, Input.AnyNonZero, true, true);
 
-		public Correctness FromMulti(int k, int pkLength)
+		public override Correctness FromMulti(int k, int pkLength)
 			=> new Correctness(Base.B, Input.AnyNonZero, true, true);
 
-		public Correctness FromAfter(uint time)
-			=> new Correctness(Base.B, Input.Zero, false, false);
-
-		public Correctness FromOlder(uint time)
-			=> new Correctness(Base.B, Input.Zero, false, false);
-
-		public Correctness FromHash()
+		public override Correctness FromHash()
 			=> new Correctness(Base.B, Input.OneNonZero, true, true);
 
-		public Correctness FromSha256()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness FromHash256()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness FromRipemd160()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness FromHash160()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness CastAlt()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness CastSwap()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness CastCheck()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness CastDupIf()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness CastVerify()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness CastNonZero()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness CastZeroNotEqual()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness CastTrue()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness CastOrIFalse()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness CastUnLikely()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness CastLikely()
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness AndB(Correctness left, Correctness right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public Correctness AndV(Correctness left, Correctness right)
-		{
-			throw new NotImplementedException();
-		}
+		public override Correctness FromTime(uint time)
+			=> new Correctness(Base.B, Input.Zero, false, false);
 
-		public Correctness AndN(Correctness left, Correctness right)
+		public override Correctness CastAlt()
+			=> new Correctness(
+				(Base == Base.B ? Base.W : throw CastException.ChildBase1(Base)),
+				Input.Any,
+				DisSatisfiable,
+				Unit
+		);
+
+		public override Correctness CastSwap() =>
+			new Correctness(
+				(Base == Base.B ? Base.W : throw CastException.ChildBase1(Base)),
+				(Input == Input.One || Input == Input.OneNonZero ? Input.Any : throw CastException.ChildBase1(Base)),
+				DisSatisfiable,
+				Unit
+				);
+
+		public override Correctness CastCheck() =>
+			new Correctness(
+				(Base == Base.K ? Base.B : throw CastException.ChildBase1(Base)),
+				Input,
+				DisSatisfiable,
+				true
+			);
+
+		public override Correctness CastDupIf() =>
+			new Correctness(
+				(Base == Base.V ? Base.B : throw CastException.ChildBase1(Base)),
+				(Input == Input.Zero ? Input.OneNonZero : throw CastException.NonZeroDupIf),
+				true,
+				true
+				);
+
+		public override Correctness CastVerify() =>
+			new Correctness(
+				(Base == Base.B ? Base.V : throw CastException.ChildBase1(Base)),
+				Input,
+				false,false
+				);
+
+		public override Correctness CastNonZero()
 		{
-			throw new NotImplementedException();
+			if (Input != Input.OneNonZero && Input != Input.AnyNonZero)
+				throw CastException.NonZeroZero;
+			return new Correctness(
+				(Base == Base.B ? Base.B : throw CastException.ChildBase1(Base)),
+				Input,
+				true,
+				Unit
+				);
 		}
 
-		public Correctness OrB(Correctness left, Correctness right)
+		public override Correctness CastZeroNotEqual() =>
+			new Correctness(
+				(Base == Base.B ? Base.B : throw CastException.ChildBase1(Base)),
+				Input,
+				DisSatisfiable,
+				true
+				);
+
+		public override Correctness CastTrue() =>
+			new Correctness(
+				(Base == Base.V ? Base.B : throw CastException.ChildBase1(Base)),
+				Input,
+				false,
+				true
+			);
+
+		public override Correctness CastOrIFalse() =>
+			new Correctness(
+				(Base == Base.B ? Base.B : throw CastException.ChildBase1(Base)),
+				(Input == Input.Zero ? Input.One : Input.Any),
+				true,
+				Unit
+				);
+
+		public override Correctness AndB(Correctness l, Correctness r) =>
+			new Correctness(
+				((l.Base == Base.B && r.Base == Base.W) ? Base.B : throw CastException.ChildBase2(l.Base, r.Base) ),
+
+				(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
+				);
+
+		public override Correctness AndV(Correctness l, Correctness r)
 		{
-			throw new NotImplementedException();
+			return new Correctness(
+				(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 : throw CastException.ChildBase2(l.Base, r.Base),
+
+				(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
+				);
 		}
 
-		public Correctness OrD(Correctness left, Correctness right)
+		public override Correctness OrB(Correctness l, Correctness r)
 		{
-			throw new NotImplementedException();
+			if (!l.DisSatisfiable)
+				throw CastException.LeftNotDissatisfiable;
+			if (!r.DisSatisfiable)
+				throw CastException.RightNotDissatisfiable;
+			return new Correctness(
+				(l.Base == Base.B && r.Base == Base.W) ? Base.B : throw CastException.ChildBase2(l.Base, r.Base),
+				(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
+				);
 		}
 
-		public Correctness OrC(Correctness left, Correctness right)
+		public override Correctness OrD(Correctness l, Correctness r)
 		{
-			throw new NotImplementedException();
+			if (!l.DisSatisfiable)
+				throw CastException.LeftNotDissatisfiable;
+			if (!l.Unit)
+				throw CastException.LeftNotUnit;
+			return new Correctness(
+				(l.Base == Base.B) ? Base.B : throw CastException.ChildBase2(l.Base, r.Base),
+				(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
+				);
 		}
 
-		public Correctness OrI(Correctness left, Correctness right)
+		public override Correctness OrC(Correctness l, Correctness r)
 		{
-			throw new NotImplementedException();
+			if (!l.DisSatisfiable)
+				throw CastException.LeftNotDissatisfiable;
+			if (!l.Unit)
+				throw CastException.LeftNotUnit;
+
+			return
+				new Correctness(
+					(l.Base == Miniscript.Base.B && r.Base == Miniscript.Base.V)
+						? Miniscript.Base.V
+						: throw CastException.ChildBase2(l.Base, r.Base),
+					Miniscript.Input.Any,
+					false,
+					false
+				);
 		}
 
-		public Correctness AndOr(Correctness a, Correctness b, Correctness c)
+		public override Correctness OrI(Correctness l, Correctness r) =>
+			new Correctness(
+				(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 : throw CastException.ChildBase2(l.Base, r.Base),
+				(l.Input == Miniscript.Input.Zero && r.Input == Miniscript.Input.Zero) ? Miniscript.Input.One : Miniscript.Input.Any,
+				(l.DisSatisfiable || r.DisSatisfiable),
+				l.Unit && r.Unit
+			);
+
+		public override Correctness AndOr(Correctness a, Correctness b, Correctness c)
 		{
-			throw new NotImplementedException();
+			if (!a.DisSatisfiable)
+				throw CastException.LeftNotDissatisfiable;
+			if (!a.Unit)
+				throw CastException.LeftNotUnit;
+			return new Correctness(
+				(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 :
+					throw CastException.ChildBase3(a.Base, b.Base, c.Base),
+				(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
+				);
 		}
 
-		public Correctness Threshold(int k, int n, Func<uint, Correctness> subCk)
+		public override Correctness Threshold(int k, int n, Func<int, Correctness> subCk)
 		{
-			throw new NotImplementedException();
+			var isN = k == n;
+			for (int i = 0; i < n; i++)
+			{
+				var subType = subCk(i);
+				if (i == 0)
+				{
+					isN &= subType.Input == Input.OneNonZero || subType.Input == Input.AnyNonZero;
+					if (subType.Base != Base.B)
+						throw CastException.ThresholdBase(0U, subType.Base);
+				}
+				else
+				{
+					if (subType.Base != Miniscript.Base.W)
+						throw CastException.ThresholdBase((uint)n, subType.Base);
+				}
+				if (!subType.Unit)
+					throw CastException.ThresholdNonUnit((uint)n);
+				if (!subType.DisSatisfiable)
+					throw CastException.ThresholdDissat((uint)n);
+			}
+			return new Correctness(
+				Base.B,
+				(isN ? Input.AnyNonZero : Miniscript.Input.Any),
+				true,
+				true
+				);
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Types/ExtData.cs b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
index 047b3eb27e..0268768193 100644
--- a/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
@@ -1,187 +1,434 @@
 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>
 	{
-		internal LegacySafe LegacySafe;
-		internal UInt64 PkCost;
-		internal bool HasVerifyForm;
-		internal UInt64 OpsCountStatic;
-		internal UInt64?  OpsCountSat;
-		internal UInt64? OpsCountNSat;
-
-		public void SanityChecks()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData FromTrue()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData FromFalse()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData FromPk()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData FromPkH()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData FromMulti(int k, int pkLength)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData FromAfter(uint time)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData FromOlder(uint time)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData FromHash()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData FromSha256()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData FromHash256()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData FromRipemd160()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData FromHash160()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData CastAlt()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData CastSwap()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData CastCheck()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData CastDupIf()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData CastVerify()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData CastNonZero()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData CastZeroNotEqual()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData CastTrue()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData CastOrIFalse()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData CastUnLikely()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData CastLikely()
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData AndB(ExtData left, ExtData right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData AndV(ExtData left, ExtData right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData AndN(ExtData left, ExtData right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData OrB(ExtData left, ExtData right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData OrD(ExtData left, ExtData right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData OrC(ExtData left, ExtData right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData OrI(ExtData left, ExtData right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData AndOr(ExtData a, ExtData b, ExtData c)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ExtData Threshold(int k, int n, Func<uint, ExtData> subCk)
-		{
-			throw new NotImplementedException();
+		/// <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 ExtData CastAlt() =>
+			new ExtData(
+				LegacySafe,
+				PkCost + 2,
+				false,
+				OpsCountStatic + 2,
+				OpsCountSat + 2,
+				OpsCountNSat + 2
+				);
+
+		public override ExtData CastSwap() =>
+			new ExtData(
+				LegacySafe,
+				PkCost + 1,
+				HasVerifyForm,
+				OpsCountStatic + 1,
+				OpsCountSat + 1,
+				OpsCountNSat + 1
+				);
+
+		public override ExtData CastCheck() =>
+			new ExtData(
+				LegacySafe,
+				PkCost + 1,
+				true,
+				OpsCountStatic + 1,
+				OpsCountSat + 1,
+				OpsCountNSat + 1
+				);
+
+		public override ExtData CastDupIf() =>
+			new ExtData(
+				LegacySafe.SegwitOnly,
+				PkCost + 3,
+				false,
+				OpsCountStatic + 3,
+				OpsCountSat + 3,
+				OpsCountStatic + 3
+				);
+
+		public override ExtData CastVerify()
+		{
+			var verifyCost = this.HasVerifyForm ? 0UL : 1UL;
+			return new ExtData(
+				LegacySafe,
+				PkCost + verifyCost,
+				false,
+				OpsCountStatic + verifyCost,
+				OpsCountSat + verifyCost,
+				null
+				);
+		}
+
+		public override ExtData CastNonZero() =>
+			new ExtData(
+				LegacySafe,
+				PkCost + 4UL,
+				false,
+				OpsCountStatic + 4,
+				OpsCountSat + 4UL,
+				OpsCountStatic + 4
+				);
+
+		public override ExtData CastZeroNotEqual() =>
+			new ExtData(
+				LegacySafe,
+				PkCost + 1,
+				false,
+				OpsCountStatic + 1,
+				OpsCountSat + 1UL,
+				OpsCountNSat + 1UL
+				);
+
+		public override ExtData CastTrue() =>
+			new ExtData(
+				LegacySafe,
+				PkCost + 1,
+				false,
+				OpsCountStatic,
+				OpsCountSat,
+				null
+				);
+
+		public override ExtData CastOrIFalse()
+		{
+			throw new Exception("Unreachable!");
+		}
+
+		public override ExtData CastUnLikely() =>
+			new ExtData(
+				LegacySafe,
+				PkCost + 4,
+				false,
+				OpsCountStatic + 3,
+				OpsCountSat + 3,
+				OpsCountNSat + 3
+				);
+
+		public override ExtData CastLikely() =>
+			new ExtData(
+				LegacySafe,
+				PkCost + 4,
+				false,
+				OpsCountStatic + 3,
+				OpsCountSat + 3,
+				OpsCountStatic + 3
+				);
+
+		private static LegacySafe LegacySafe2(LegacySafe a, LegacySafe b) =>
+			(a == LegacySafe.LegacySafe && b == LegacySafe.LegacySafe) ? LegacySafe.LegacySafe : LegacySafe.SegwitOnly;
+		public override ExtData AndB(ExtData l, ExtData r) =>
+			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
+				);
+
+		public override ExtData AndV(ExtData l, ExtData r) =>
+			new ExtData(
+				LegacySafe2(l.LegacySafe, r.LegacySafe),
+				l.PkCost + r.PkCost,
+				r.HasVerifyForm,
+				l.OpsCountStatic + r.OpsCountStatic,
+				l.OpsCountSat + r.OpsCountSat,
+				null
+				);
+
+		public override ExtData OrB(ExtData left, ExtData right) =>
+			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
+				);
+
+		public override ExtData OrD(ExtData left, ExtData right)
+		{
+			var opsCountSat1 = left.OpsCountSat + 3 + right.OpsCountStatic;
+			var opsCountSat2 = right.OpsCountSat + left.OpsCountNSat + 3;
+			return 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
+			);
+		}
+
+		public override ExtData OrC(ExtData left, ExtData right)
+		{
+			var opsCountSat1 = left.OpsCountSat + 2 + right.OpsCountStatic;
+			var opsCountSat2 = right.OpsCountSat + left.OpsCountNSat + 2;
+
+			return
+			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
+			);
+		}
+
+		public override ExtData OrI(ExtData left, ExtData right)
+		{
+			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;
+			return 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
+				);
+		}
+
+		public override ExtData AndOr(ExtData a, ExtData b, ExtData c)
+		{
+			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;
+
+			return new ExtData(
+				legacySafe,
+				a.PkCost + b.PkCost + c.PkCost + 2,
+				false,
+				a.OpsCountStatic + b.OpsCountStatic + c.OpsCountStatic + 3,
+				opsCountSat,
+				opsCountNSat
+				);
+		}
+
+		public override ExtData Threshold(int k, int n, Func<int, ExtData> subCk)
+		{
+			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++)
+			{
+				var sub = subCk(i);
+				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 ?? 0UL;
+				sum = (ulong)opsCountSatVec.Skip(remainingSat).Sum(summer);
+			}
+			return new ExtData(
+				legacySafe,
+				pkCost + (ulong)n - 1UL,
+				true,
+				opsCountStatic + ((ulong)n - 1UL) + 1UL,
+				opsCountSat + ((ulong)n - 1UL) + (sum + opsCountNSatSum),
+				opsCountNSat + ((ulong)n - 1UL) + 1UL
+				);
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
index e05dfa492b..cebfe7fc67 100644
--- a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
@@ -1,44 +1,59 @@
 using System;
 using System.Linq;
+using NBitcoin.Scripting.Miniscript.Policy;
 
 namespace NBitcoin.Scripting.Miniscript.Types
 {
-	public interface IProperty<T> where T: IProperty<T>
+	public abstract class IProperty<T> where T: IProperty<T>
 	{
-		void SanityChecks();
-		T FromTrue();
-		T FromFalse();
-		T FromPk();
-		T FromPkH();
-		T FromMulti(int k, int pkLength);
-		T FromAfter(uint time);
-		T FromOlder(uint time);
-		T FromHash();
-		T FromSha256();
-		T FromHash256();
-		T FromRipemd160();
-		T FromHash160();
-
-		T CastAlt();
-		T CastSwap();
-		T CastCheck();
-		T CastDupIf();
-		T CastVerify();
-		T CastNonZero();
-		T CastZeroNotEqual();
-		T CastTrue();
-		T CastOrIFalse();
-		T CastUnLikely();
-		T CastLikely();
-		T AndB(T left, T right);
-		T AndV(T left, T right);
-		T AndN(T left, T right);
-		T OrB(T left, T right);
-		T OrD(T left, T right);
-		T OrC(T left, T right);
-		T OrI(T left, T right);
-		T AndOr(T a, T b, T c);
-		T Threshold(int k, int n, Func<uint, T> subCk);
+		public virtual void SanityChecks() {}
+
+		# region Casting operation
+		public abstract T CastAlt();
+		public abstract T CastSwap();
+		public abstract T CastCheck();
+		public abstract T CastDupIf();
+		public abstract T CastVerify();
+		public abstract T CastNonZero();
+		public abstract T CastZeroNotEqual();
+		public abstract T CastTrue();
+		public abstract T CastOrIFalse();
+		public virtual T CastUnLikely() => CastOrIFalse();
+		public virtual T CastLikely() => CastOrIFalse();
+
+		#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 T AndB(T l, T r);
+		public abstract T AndV(T l, T r);
+		public virtual T AndN(T l, T r) => AndOr(l, r, FromFalse());
+		public abstract T OrB(T left, T right);
+		public abstract T OrD(T left, T right);
+		public abstract T OrC(T left, T right);
+		public abstract T OrI(T left, T right);
+		public abstract T AndOr(T a, T b, T c);
+		public abstract T Threshold(int k, int n, Func<int, T> subCk);
+		#endregion
 	}
 
 	public enum ErrorKind
@@ -48,11 +63,6 @@ public enum ErrorKind
 		/// </summary>
 		ZeroTime,
 
-		/// <summary>
-		/// Passed a `z` argument to a `d` wrapper when `z` was expected
-		/// </summary>
-		NonZeroDupIf,
-
 		/// <summary>
 		/// Multisignature or threshold policy had a `k` value of 0
 		/// </summary>
@@ -71,48 +81,65 @@ public enum ErrorKind
 		/// </summary>
 		NoStrongChild,
 
+
+
 		/// <summary>
-		/// Many fragments (all disjunctions except `or_i` as well as
-		/// `andor`) require their left child be dissatisfiable.
+		/// Insufficiently many children of a threshold fragment were strong
 		/// </summary>
-		LeftNotDissatisfiable,
+		ThresholdNotStrong
+	}
+
+	internal enum CastErrorKind
+	{
 
 		/// <summary>
-		/// `or_b` requires its right child be dissatisfiable
+		/// Attempted to construct a wrapper, but the child had an invalid type
 		/// </summary>
-		RightNotDissatisfiable,
+		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>
-		/// Tried to use `s:` modifier on a fragment that takes more than one input
+		/// Passed a `z` argument to a `d` wrapper when `z` was expected
 		/// </summary>
-		NonZeroZero,
+		NonZeroDupIf,
 
 		/// <summary>
-		/// Many fragments require their left child to be a unit. This
-		/// was not the case.
+		/// Tried to use `s:` modifier on a fragment that takes more than one input
 		/// </summary>
-		LeftNotUnit,
+		NonZeroZero,
 
 		/// <summary>
-		/// Attempted to construct a wrapper, but the child had an invalid type
+		/// Many fragments (all disjunctions except `or_i` as well as
+		/// `andor`) require their left child be dissatisfiable.
 		/// </summary>
-		ChildBase1,
+		LeftNotDissatisfiable,
 
 		/// <summary>
-		/// Attempted to construct a conjunction or disjunction
+		/// `or_b` requires its right child be dissatisfiable
 		/// </summary>
-		ChildBase2,
+		RightNotDissatisfiable,
 
 		/// <summary>
-		/// Attempted to construct an `andor` but the fragments
-		/// children were of invalid types
+		/// Many fragments require their left child to be a unit. This
+		/// was not the case.
 		/// </summary>
-		ChildBase3,
+		LeftNotUnit,
 
 		/// <summary>
 		/// The nth child of a threshold fragment had an invalid type (the
@@ -130,10 +157,51 @@ public enum ErrorKind
 		/// </summary>
 		ThresholdNonUnit,
 
-		/// <summary>
-		/// Insufficiently many children of a threshold fragment were strong
-		/// </summary>
-		ThresholdNotStrong
+	}
+
+	internal class CastException : InvalidCastException
+	{
+		internal CastErrorKind Kind;
+
+		private CastException(CastErrorKind e, string msg) : base(
+			$"Failed to cast. kind {e.ToString("G")}. msg: {msg} ")
+		{
+			Kind = e;
+		}
+
+		public static CastException LeftNotUnit =
+			new CastException(CastErrorKind.LeftNotUnit, "this fragment requires left to be unit. But it was not.");
+
+		public static CastException ChildBase1(Base b) =>
+			new CastException(CastErrorKind.ChildBase1, $"Attempted to construct a wrapper. But the child had an invalid type {b.ToString("G")}");
+		public static CastException ChildBase2(Base l, Base r) =>
+			new CastException(CastErrorKind.ChildBase2, $"Attempted to construct a wrapper. But the child had an invalid type. left: {l.ToString("G")}. right: {r.ToString("G")}");
+
+		public static CastException ChildBase3(Base a, Base b, Base c) =>
+			new CastException(CastErrorKind.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")}");
+
+		public static CastException SwapNoneOne =
+			new CastException(CastErrorKind.SwapNonOne, "Tried to use the s: modifier for the fragment takes more than one output.");
+
+		public static CastException NonZeroDupIf =
+			new CastException(CastErrorKind.NonZeroDupIf, $"Passed a z argument to a d wrapper when `z` was expected.");
+
+		public static CastException NonZeroZero =
+			new CastException(CastErrorKind.NonZeroZero, "Tried to use `s:` modifier on a fragment that takes more than one input");
+		public static CastException LeftNotDissatisfiable =
+			new CastException(CastErrorKind.LeftNotDissatisfiable, "Left child must be dissatisfiable");
+		public static CastException RightNotDissatisfiable =
+			new CastException(CastErrorKind.RightNotDissatisfiable, "Right child must be dissatisfiable.");
+
+		public static CastException ThresholdBase(uint i, Base b) =>
+			new CastException(CastErrorKind.ThresholdBase,
+				$"the {i}th value of the threshold fragment had an invalid type (first must be `B` and rest must be `W`.)");
+
+		public static CastException ThresholdNonUnit(uint n) =>
+			new CastException(CastErrorKind.ThresholdNonUnit, "the {n} th fragment of the threshold was not the unit");
+
+		public static CastException ThresholdDissat(uint n) =>
+			new CastException(CastErrorKind.ThresholdDissat, $"the {n}th child of the threshold did not have unique satisfaction");
 	}
 
 	class TypeCheckException<TPk, TPKh> : Exception
diff --git a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
index bbabea9f46..313780cbb2 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -59,160 +59,166 @@ internal bool IsSubtype(Malleability other) =>
 				other.Safe &&
 				!(!NonMalleable && other.NonMalleable);
 
-		public Malleability FromTrue() =>
+		public override Malleability FromTrue() =>
 			new Malleability(Dissat.None, false, true);
 
-		public Malleability FromFalse() =>
+		public override Malleability FromFalse() =>
 			new Malleability(Dissat.None, true, true);
 
-		public Malleability FromPk() =>
+		public override Malleability FromPk() =>
 			new Malleability(Dissat.Unique, true, true);
 
-		public Malleability FromPkH() =>
+		public override Malleability FromPkH() =>
 			new Malleability(Dissat.Unique, true, true);
 
-		public Malleability FromMulti(int k, int pkLength) =>
+		public override Malleability FromMulti(int k, int pkLength) =>
 			new Malleability(Dissat.Unique, true,true);
 
-		public Malleability FromAfter(uint time)
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability FromOlder(uint time)
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability FromHash() =>
+		public override Malleability FromTime(uint time) =>
 			new Malleability(Dissat.None, false, true);
 
-		public Malleability FromSha256()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability FromHash256()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability FromRipemd160()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability FromHash160()
-		{
-			throw new System.NotImplementedException();
-		}
+		public override Malleability FromHash() =>
+			new Malleability(Dissat.None, false, true);
 
-		public Malleability CastAlt() =>
+		public override Malleability CastAlt() =>
 			this;
 
-		public Malleability CastSwap()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability CastCheck()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability CastDupIf()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability CastVerify()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability CastNonZero()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability CastZeroNotEqual()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability CastTrue()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability CastOrIFalse()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability CastUnLikely()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability CastLikely()
-		{
-			throw new System.NotImplementedException();
-		}
-
-		public Malleability AndB(Malleability left, Malleability right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public Malleability AndV(Malleability left, Malleability right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public Malleability AndN(Malleability left, Malleability right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public Malleability OrB(Malleability left, Malleability right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public Malleability OrD(Malleability left, Malleability right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public Malleability OrC(Malleability left, Malleability right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public Malleability OrI(Malleability left, Malleability right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public Malleability AndOr(Malleability a, Malleability b, Malleability c)
-		{
-			throw new NotImplementedException();
-		}
-
-		public Malleability Threshold(int k, int n, Func<uint, Malleability> subCk)
-		{
-			throw new NotImplementedException();
-		}
+		public override Malleability CastSwap() =>
+			this;
 
-		public Malleability AndB()
-		{
-			throw new System.NotImplementedException();
-		}
+		public override Malleability CastCheck() =>
+			this;
 
-		public void SanityChecks()
-		{
-			throw new System.NotImplementedException();
+		public override Malleability CastDupIf() =>
+			new Malleability(
+				(Dissat == Dissat.None ? Dissat.Unique : Dissat.Unknown),
+				Safe,
+				NonMalleable
+				);
+
+		public override Malleability CastVerify() =>
+			new Malleability(
+				Dissat.None,
+				Safe,
+				NonMalleable
+				);
+
+		public override Malleability CastNonZero() =>
+			new Malleability(
+				Dissat == Dissat.None ? Dissat.Unique : Dissat.Unknown,
+				Safe,
+				NonMalleable
+				);
+
+		public override Malleability CastZeroNotEqual() => this;
+
+		public override Malleability CastTrue() =>
+			new Malleability(
+				Dissat == Dissat.None ? Dissat.Unique : Dissat.Unknown,
+				Safe,
+				NonMalleable
+				);
+
+		public override Malleability CastOrIFalse() =>
+			new Malleability(
+				Dissat == Dissat.None ? Dissat.Unique : Dissat.Unknown,
+				Safe,
+				NonMalleable
+				);
+
+		public override Malleability AndB(Malleability left, Malleability right) =>
+			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
+				);
+
+
+		public override Malleability AndV(Malleability left, Malleability right) =>
+			new Malleability(
+				(left.Safe) || (right.Dissat == Dissat.None) ? Dissat.None : Dissat.Unknown,
+				left.Safe || right.Safe,
+				left.NonMalleable && right.NonMalleable
+				);
+
+		public override Malleability OrB(Malleability left, Malleability right) =>
+			new Malleability(
+				Dissat.Unique,
+				left.Safe && right.Safe,
+				left.NonMalleable
+				&& left.Dissat == Dissat.Unique
+				&& right.NonMalleable
+				&& right.Dissat == Dissat.Unique
+				&& (left.Safe || right.Safe)
+				);
+
+		public override Malleability OrD(Malleability left, Malleability right) =>
+			new Malleability(
+				right.Dissat,
+				left.Safe && right.Safe,
+				left.NonMalleable
+				&& left.Dissat == Dissat.Unique
+				&& right.NonMalleable
+				&& (left.Safe || right.Safe)
+				);
+
+
+		public override Malleability OrC(Malleability left, Malleability right) =>
+			new Malleability(
+				Dissat.None,
+				left.Safe && right.Safe,
+				left.NonMalleable
+				&& left.Dissat == Dissat.Unique
+				&& right.NonMalleable
+				&& (left.Safe && right.Safe)
+				);
+
+		public override Malleability OrI(Malleability left, Malleability right) =>
+			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)
+				);
+
+		public override Malleability AndOr(Malleability a, Malleability b, Malleability c) =>
+			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)
+				);
+
+		public override Malleability Threshold(int k, int n, Func<int, Malleability> subCk)
+		{
+			var safeCount = 0;
+			var allAreDissatUnique = true;
+			var allAreNonMalleable = true;
+			for (int i = 0; i < n; i++)
+			{
+				var subType = subCk(i);
+				safeCount += (subType.Safe ? 1 : 0);
+				allAreDissatUnique &= subType.Dissat == Dissat.Unique;
+				allAreNonMalleable &= subType.NonMalleable;
+			}
+			return new Malleability(
+				allAreDissatUnique && (k == 1 || safeCount == n) ? Dissat.Unique : Dissat.Unknown,
+					safeCount > n - k,
+					allAreNonMalleable && safeCount >= n -k && (k == n || allAreDissatUnique)
+				);
 		}
 
 	}
diff --git a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
index 5d128b8e59..57fd9a2ff5 100644
--- a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
@@ -21,10 +21,10 @@ private MiniscriptFragmentType(Correctness correctness, Malleability malleabilit
 		public MiniscriptFragmentType() {}
 
 		public bool IsSubtype(MiniscriptFragmentType other) =>
-			this.Correctness.IsSubtype(other.Correctness) &&
-			this.Malleability.IsSubtype(other.Malleability);
+			Correctness.IsSubtype(other.Correctness) &&
+			Malleability.IsSubtype(other.Malleability);
 
-		public void SanityChecks()
+		public override void SanityChecks()
 		{
 			Debug.Assert(!this.Correctness.DisSatisfiable || this.Malleability.Dissat != Dissat.None);
 			Debug.Assert(this.Malleability.Dissat == Dissat.None || this.Correctness.Base != Base.K);
@@ -32,255 +32,189 @@ public void SanityChecks()
 			Debug.Assert(this.Malleability.NonMalleable || this.Correctness.Input != Input.Zero);
 		}
 
-		public MiniscriptFragmentType FromTrue()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(cor.FromTrue(), mal.FromTrue());
-		}
-
-		public MiniscriptFragmentType FromFalse()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(cor.FromFalse(), mal.FromFalse());
-		}
-
-		public MiniscriptFragmentType FromPk()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(cor.FromPk(), mal.FromPk());
-		}
-
-		public MiniscriptFragmentType FromPkH()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(cor.FromPkH(), mal.FromPkH());
-		}
-
-		public MiniscriptFragmentType FromMulti(int k, int pkLength)
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(cor.FromMulti(k, pkLength), mal.FromMulti(k, pkLength));
-		}
-
-		public MiniscriptFragmentType FromAfter(uint time)
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.FromAfter(time),
-				mal.FromAfter(time));
-		}
-
-		public MiniscriptFragmentType FromOlder(uint time)
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.FromOlder(time),
-				mal.FromOlder(time));
-		}
-
-		public MiniscriptFragmentType FromHash()
-		{
-
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.FromHash(),
-				mal.FromHash());
-		}
-
-		public MiniscriptFragmentType FromSha256()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.FromSha256(),
-				mal.FromSha256());
-		}
-
-		public MiniscriptFragmentType FromHash256()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.FromHash256(),
-				mal.FromHash256());
-		}
-
-		public MiniscriptFragmentType FromRipemd160()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.FromRipemd160(),
-				mal.FromRipemd160());
-		}
-
-		public MiniscriptFragmentType FromHash160()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.FromHash160(),
-				mal.FromHash160());
-		}
-
-		public MiniscriptFragmentType CastAlt()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.CastAlt(),
-				mal.CastAlt());
-		}
-
-		public MiniscriptFragmentType CastSwap()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.CastSwap(),
-				mal.CastSwap());
-		}
-
-		public MiniscriptFragmentType CastCheck()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.CastCheck(),
-				mal.CastCheck());
-		}
-
-		public MiniscriptFragmentType CastDupIf()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.CastDupIf(),
-				mal.CastDupIf());
-		}
-
-		public MiniscriptFragmentType CastVerify()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.CastVerify(),
-				mal.CastVerify());
-		}
-
-		public MiniscriptFragmentType CastNonZero()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.CastNonZero(),
-				mal.CastNonZero());
-		}
-
-		public MiniscriptFragmentType CastZeroNotEqual()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.CastZeroNotEqual(),
-				mal.CastZeroNotEqual());
-		}
-
-		public MiniscriptFragmentType CastTrue()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.CastTrue(),
-				mal.CastTrue());
-		}
-
-		public MiniscriptFragmentType CastOrIFalse()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.CastOrIFalse(),
-				mal.CastOrIFalse());
-		}
-
-		public MiniscriptFragmentType CastUnLikely()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.CastUnLikely(),
-				mal.CastUnLikely());
-		}
-
-		public MiniscriptFragmentType CastLikely()
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.CastLikely(),
-				mal.CastLikely());
-		}
-
-		public MiniscriptFragmentType AndB(MiniscriptFragmentType left, MiniscriptFragmentType right)
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.AndB(left.Correctness, right.Correctness),
-				mal.AndB(left.Malleability, right.Malleability));
-		}
-
-		public MiniscriptFragmentType AndV(MiniscriptFragmentType left, MiniscriptFragmentType right)
-		{
-			var cor = new Correctness();
-			var mal = new Malleability();
-			return new MiniscriptFragmentType(
-				cor.AndV(left.Correctness, right.Correctness),
-				mal.AndV(left.Malleability, right.Malleability));
-		}
-
-		public MiniscriptFragmentType AndN(MiniscriptFragmentType left, MiniscriptFragmentType right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public MiniscriptFragmentType OrB(MiniscriptFragmentType left, MiniscriptFragmentType right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public MiniscriptFragmentType OrD(MiniscriptFragmentType left, MiniscriptFragmentType right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public MiniscriptFragmentType OrC(MiniscriptFragmentType left, MiniscriptFragmentType right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public MiniscriptFragmentType OrI(MiniscriptFragmentType left, MiniscriptFragmentType right)
-		{
-			throw new NotImplementedException();
-		}
-
-		public MiniscriptFragmentType AndOr(MiniscriptFragmentType a, MiniscriptFragmentType b, MiniscriptFragmentType c)
-		{
-			throw new NotImplementedException();
-		}
-
-		public MiniscriptFragmentType Threshold(int k, int n, Func<uint, MiniscriptFragmentType> subCk)
-		{
-			throw new NotImplementedException();
-		}
+		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 MiniscriptFragmentType CastAlt()
+			=>
+			new MiniscriptFragmentType(
+				Correctness.CastAlt(),
+				Malleability.CastAlt());
+
+		public override MiniscriptFragmentType CastSwap()
+			=> new MiniscriptFragmentType(
+				Correctness.CastSwap(),
+				Malleability.CastSwap());
+
+		public override MiniscriptFragmentType CastCheck()
+			=> new MiniscriptFragmentType(
+				Correctness.CastCheck(),
+				Malleability.CastCheck());
+
+		public override MiniscriptFragmentType CastDupIf()
+			=> new MiniscriptFragmentType(
+				Correctness.CastDupIf(),
+				Malleability.CastDupIf());
+
+		public override MiniscriptFragmentType CastVerify()
+			=> new MiniscriptFragmentType(
+				Correctness.CastVerify(),
+				Malleability.CastVerify());
+		public override MiniscriptFragmentType CastNonZero()
+			=>
+			new MiniscriptFragmentType(
+				Correctness.CastNonZero(),
+				Malleability.CastNonZero());
+
+		public override MiniscriptFragmentType CastZeroNotEqual()
+			=>
+			new MiniscriptFragmentType(
+				Correctness.CastZeroNotEqual(),
+				Malleability.CastZeroNotEqual());
+
+		public override MiniscriptFragmentType CastTrue()
+			=>
+			new MiniscriptFragmentType(
+				Correctness.CastTrue(),
+				Malleability.CastTrue());
+
+		public override MiniscriptFragmentType CastOrIFalse()
+			=>
+			new MiniscriptFragmentType(
+				Correctness.CastOrIFalse(),
+				Malleability.CastOrIFalse());
+
+		public override MiniscriptFragmentType CastUnLikely()
+			=>
+			new MiniscriptFragmentType(
+				Correctness.CastUnLikely(),
+				Malleability.CastUnLikely());
+
+		public override MiniscriptFragmentType CastLikely()
+			=>
+			new MiniscriptFragmentType(
+				Correctness.CastLikely(),
+				Malleability.CastLikely());
+
+		public override MiniscriptFragmentType AndB(MiniscriptFragmentType left, MiniscriptFragmentType right)
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().AndB(left.Correctness, right.Correctness),
+				new Malleability().AndB(left.Malleability, right.Malleability));
+
+		public override MiniscriptFragmentType AndV(MiniscriptFragmentType left, MiniscriptFragmentType right)
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().AndV(left.Correctness, right.Correctness),
+				new Malleability().AndV(left.Malleability, right.Malleability));
+
+
+		public override MiniscriptFragmentType OrB(MiniscriptFragmentType left, MiniscriptFragmentType right)
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().OrB(left.Correctness, right.Correctness),
+				new Malleability().OrB(left.Malleability, right.Malleability));
+
+		public override MiniscriptFragmentType OrD(MiniscriptFragmentType left, MiniscriptFragmentType right)
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().OrD(left.Correctness, right.Correctness),
+				new Malleability().OrD(left.Malleability, right.Malleability));
+
+		public override MiniscriptFragmentType OrC(MiniscriptFragmentType left, MiniscriptFragmentType right)
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().OrC(left.Correctness, right.Correctness),
+				new Malleability().OrC(left.Malleability, right.Malleability));
+
+		public override MiniscriptFragmentType OrI(MiniscriptFragmentType left, MiniscriptFragmentType right)
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().OrI(left.Correctness, right.Correctness),
+				new Malleability().OrI(left.Malleability, right.Malleability));
+
+		public override MiniscriptFragmentType AndOr(MiniscriptFragmentType a, MiniscriptFragmentType b, MiniscriptFragmentType c)
+			=>
+			new MiniscriptFragmentType(
+				new Correctness().AndOr(a.Correctness, b.Correctness, c.Correctness),
+				new Malleability().AndOr(a.Malleability, b.Malleability, c.Malleability));
+
+		public override MiniscriptFragmentType Threshold(int k, int n, Func<int, MiniscriptFragmentType> func)
+			=>
+				new MiniscriptFragmentType(
+					new Correctness().Threshold(k, n, i => func(i).Correctness),
+					new Malleability().Threshold(k, n , i => func(i).Malleability));
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Types/Property.cs b/NBitcoin/Scripting/Miniscript/Types/Property.cs
index 67ca29afa3..990d4661cd 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Property.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Property.cs
@@ -4,32 +4,10 @@
 namespace NBitcoin.Scripting.Miniscript.Types
 {
 	public static class Property<T, TPk, TPKh>
-	where T : class, IProperty<T>, new()
+	where T : IProperty<T>, new()
 	where TPk : class, IMiniscriptKey<TPKh>, new()
 	where TPKh : class, IMiniscriptKeyHash, new()
 	{
-		/*
-		internal static void SanityChecks(T item)
-		{
-			if (item is Correctness correctness)
-				throw new NotImplementedException();
-
-			// no check for default.
-		}
-
-		internal static T FromTrue(T item)
-		{
-			if (item is CompilerExtData compilerExtData)
-				throw new NotSupportedException("Unreachable");
-		}
-
-		internal static IProperty<T> FromFalse(T item)
-		{
-			if (item is CompilerExtData compilerExtData)
-				return new CompilerExtData(null, double.MaxValue, 0.0);
-		}
-		*/
-
 
 		/// <summary>
 		/// Compute the type of a fragment, given a function to look up
diff --git a/NBitcoin/Scripting/Miniscript/Utils.cs b/NBitcoin/Scripting/Miniscript/Utils.cs
new file mode 100644
index 0000000000..6ecbf3af2d
--- /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 < 0x10) // 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>
+		}
+	}
+}

From 07518c76bfacdcaef7e5a8a2d01acce85379734d Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Thu, 7 Nov 2019 16:49:11 +0900
Subject: [PATCH 11/50] Use single Exception for Internal Error

---
 NBitcoin.Tests/MiniscriptTests.cs             |  28 ++-
 NBitcoin/Policy/ITransactionPolicy.cs         |   2 +-
 .../MiniscriptDSLParser.Terminal.cs           |   2 +-
 .../MiniscriptDSLParsers.ConcretePolicy.cs    |  10 +-
 .../Scripting/Miniscript/Policy/Compiler.cs   |  98 +++++++++-
 .../Scripting/Miniscript/Types/Correctness.cs |  62 +++----
 .../Types/FragmentPropertyException.cs        | 166 +++++++++++++++++
 .../Scripting/Miniscript/Types/IProperty.cs   | 174 ------------------
 .../Types/MiniscriptFragmentType.cs           |   2 +-
 .../Scripting/Miniscript/Types/Property.cs    |  17 +-
 10 files changed, 329 insertions(+), 232 deletions(-)
 create mode 100644 NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 1594d6cdcd..a65fee219f 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using NBitcoin.DataEncoders;
 using NBitcoin.Scripting.Miniscript;
 using NBitcoin.Scripting.Miniscript.Policy;
@@ -10,6 +11,18 @@ namespace NBitcoin.Tests
 	public class MiniscriptTests
 	{
 		public static HexEncoder Hex = new DataEncoders.HexEncoder();
+
+		public static Key[] PrivKeys = (new []
+			{
+				"4141414141414141414141414141414141414141414141414141414141414141",
+				"4242424242424242424242424242424242424242424242424242424242424242",
+				"4343434343434343434343434343434343434343434343434343434343434343",
+				"4444444444444444444444444444444444444444444444444444444444444444",
+				"4545454545454545454545454545454545454545454545454545454545454545",
+			}).Select(str => new Key(Hex.DecodeData(str))).ToArray();
+
+		public static PubKey[] PubKeys = PrivKeys.Select(k => k.PubKey).ToArray();
+
 		public static readonly TheoryData<string, string, bool, bool, bool, uint, uint> MSAttributeTestCase =
 			new TheoryData<string, string, bool, bool, bool, uint, uint>()
 			{
@@ -195,17 +208,26 @@ public void PolicyParserTest()
 		{
 			ConcretePolicy<MiniscriptStringKey, MiniscriptStringKeyHash>.Parse("pk(foo)");
 
-			var pk = new Key(Hex.DecodeData("4141414141414141414141414141414141414141414141414141414141414141")).PubKey;
 			Assert.Throws<ParsingException>(() => ConcretePolicy<PubKey, uint160>.Parse("pk(foo)"));
-			var msRealPK = ConcretePolicy<PubKey, uint160>.Parse($"pk({pk})");
+			var msRealPK = ConcretePolicy<PubKey, uint160>.Parse($"pk({PubKeys[0]})");
 			Assert.True(msRealPK.IsValid());
+
+			var strOr = $"or(99@pk({PubKeys[0]}),pk({PubKeys[1]}))";
+			// var strOr = $"or(pk({PubKeys[0]}),pk({PubKeys[1]}))";
+			// var msRealOr = ConcretePolicy<PubKey, uint160>.Parse(strOr);
+			var msRealOr = MiniscriptDSLParser<PubKey, uint160>.PSubExprs("or", MiniscriptDSLParser<PubKey, uint160>.POrWithProb).Parse(strOr);
+			// Assert.True(msRealOr.IsValid());
 		}
 
 		[Fact]
 		[Trait("UnitTest", "UnitTest")]
 		public void MiniscriptParserTest()
 		{
-			var ms = Miniscript<PubKey, uint160>.Parse();
+			var pkStr = $"c:pk({PubKeys[0]})";
+			var orStr = $"or_b(c:pk({PubKeys[0]}),sc:pk({PubKeys[1]}))";
+			// var orMs = Miniscript<PubKey, uint160>.Parse(orStr);
+			var pkRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(pkStr);
+			var orRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(orStr);
 		}
 	}
 }
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/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
index d3ac459bfb..3c0e644c18 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
@@ -55,7 +55,7 @@ private static Parser<char, Terminal<TPk, TPKh>> PWrapper(char identifier,
 			=>
 				from _t in Parse.Char(identifier).Then(_ => Parse.Char(':'))
 				from inner in Parse.Ref(() => TerminalDSLParser)
-					.Except(PWrapper(identifier, construct)) // should not have same wrapper twice
+					.Except(PWrapper(identifier, construct)) // should not have the same wrapper twice
 				select construct(Miniscript<TPk, TPKh>.FromAst(inner));
 
 		private static Parser<char, Terminal<TPk, TPKh>> PBinary(
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
index bf11f3d751..badc53e9ca 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
@@ -152,7 +152,7 @@ private static Parser<char, ConcretePolicy<TPk, TPKh>> POlderExpr()
 			from t in ExprP("older").Then(s => TryConvert(s, UInt32.Parse))
 			select ConcretePolicy<TPk, TPKh>.NewOlder(t);
 
-		private static Parser<char, IEnumerable<TSub>> PSubExprs<TSub>(string name, Func<Parser<char, TSub>> subP) =>
+		internal static Parser<char, IEnumerable<TSub>> PSubExprs<TSub>(string name, Func<Parser<char, TSub>> subP) =>
 			from _n in Parse.String(name)
 			from _left in Parse.Char('(')
 			from x in Parse
@@ -166,20 +166,20 @@ private static Parser<char, ConcretePolicy<TPk, TPKh>> PAndExpr()
 			from x in PSubExprs("and", DSLParser)
 			select ConcretePolicy<TPk, TPKh>.NewAnd(x);
 
-		private static Parser<char, Tuple<uint, ConcretePolicy<TPk, TPKh>>> POrWithProb()
+		internal static Parser<char, Tuple<uint, ConcretePolicy<TPk, TPKh>>> POrWithProb()
 			=>
 			from x in Parse.Digit.AtLeastOnce().Text()
 				.Then(digitStr => TryConvert(digitStr, UInt32.Parse))
 			from _a in Parse.Char('@')
-			from sub in Parse.Ref(() => DSLParser())
+			from sub in Parse.Ref( DSLParser)
 			select Tuple.Create(x, sub);
 
 		private static Parser<char, Tuple<uint, ConcretePolicy<TPk, TPKh>>> POrWithoutProb()
 			=>
-			from sub in Parse.Ref(() => DSLParser())
+			from sub in Parse.Ref(DSLParser)
 			select Tuple.Create(1U, sub);
 
-		private static Parser<char, ConcretePolicy<TPk, TPKh>> POrExpr()
+		internal static Parser<char, ConcretePolicy<TPk, TPKh>> POrExpr()
 			=>
 			from x in
 				PSubExprs("or", POrWithProb)
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index 07f508d792..3d4c86c2e2 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -207,7 +207,7 @@ public override CompilerExtData OrI(CompilerExtData left, CompilerExtData right)
 
 		public override CompilerExtData AndOr(CompilerExtData a, CompilerExtData b, CompilerExtData c)
 		{
-			if (!a.DissatCost.HasValue) throw CastException.LeftNotDissatisfiable;
+			if (!a.DissatCost.HasValue) throw FragmentPropertyException.LeftNotDissatisfiable();
 			var aProb = a.BranchProb.Value;
 			var bProb = b.BranchProb.Value;
 			var cProb = c.BranchProb.Value;
@@ -484,7 +484,7 @@ private static void InsertElemClosure(
 						var newExt = c.InvokeCast();
 						if (InsertElem(map, newExt, satProb, dissatProb))
 							castStack.Push(newExt);
-					} catch (CastException e) {}
+					} catch (FragmentPropertyException e) {}
 				}
 			}
 		}
@@ -529,7 +529,7 @@ private static void InsertBestWrapped(
 							var newExt = c.InvokeCast();
 							InsertElemClosure(map, newExt, satProb, dissatProb);
 						}
-						catch (CastException _)
+						catch (FragmentPropertyException _)
 						{
 						}
 					}
@@ -810,7 +810,7 @@ Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> binFunc
 					{
 						var newExt = AstElemExt<TPk, TPKh>.Binary(ast, l, r);
 						InsertBestWrapped(policyCache, policy, ret, newExt, satProb, dissatProb);
-					} catch (TypeCheckException<TPk, TPKh> ex) {}
+					} catch (FragmentPropertyException ex) {}
 				}
 			}
 			throw new NotImplementedException();
@@ -829,6 +829,25 @@ private static void CompileTernary(
 			double? dissatProb
 			)
 		{
+			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);
+						try
+						{
+							var newExt = AstElemExt<TPk, TPKh>.Ternary(ast, a, b, c);
+							InsertBestWrapped(policyCache, policy, ret, newExt, satProb, dissatProb);
+						} catch (FragmentPropertyException ex)
+						{}
+					}
+				}
+			}
 		}
 
 		public static Miniscript<TPk, TPKh> BestCompilation(ConcretePolicy<TPk, TPKh> policy)
@@ -844,6 +863,15 @@ public static Miniscript<TPk, TPKh> BestCompilation(ConcretePolicy<TPk, TPKh> po
 			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>
 		private static AstElemExt<TPk, TPKh> BestT(
 			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
 				policyCache,
@@ -852,9 +880,31 @@ private static AstElemExt<TPk, TPKh> BestT(
 			double? dissatProb
 			)
 		{
-			throw new NotImplementedException();
+			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,
@@ -863,7 +913,24 @@ private static AstElemExt<TPk, TPKh> BestE(
 				double? dissatProb
 			)
 		{
-			throw new NotImplementedException();
+			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;
+						}
+					);
 		}
 
 		private static AstElemExt<TPk, TPKh> BestW(
@@ -874,7 +941,24 @@ private static AstElemExt<TPk, TPKh> BestW(
 				double? dissatProb
 			)
 		{
-			throw new NotImplementedException();
+			var result =
+				BestCompilations(policyCache, policy, satProb, dissatProb)
+					.Where(kv =>
+						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/Types/Correctness.cs b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
index eb378fe58e..8aea31dd18 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
@@ -70,7 +70,7 @@ public override Correctness FromTime(uint time)
 
 		public override Correctness CastAlt()
 			=> new Correctness(
-				(Base == Base.B ? Base.W : throw CastException.ChildBase1(Base)),
+				(Base == Base.B ? Base.W : throw FragmentPropertyException.ChildBase1(Base)),
 				Input.Any,
 				DisSatisfiable,
 				Unit
@@ -78,15 +78,15 @@ public override Correctness CastAlt()
 
 		public override Correctness CastSwap() =>
 			new Correctness(
-				(Base == Base.B ? Base.W : throw CastException.ChildBase1(Base)),
-				(Input == Input.One || Input == Input.OneNonZero ? Input.Any : throw CastException.ChildBase1(Base)),
+				(Base == Base.B ? Base.W : throw FragmentPropertyException.ChildBase1(Base)),
+				(Input == Input.One || Input == Input.OneNonZero ? Input.Any : throw FragmentPropertyException.ChildBase1(Base)),
 				DisSatisfiable,
 				Unit
 				);
 
 		public override Correctness CastCheck() =>
 			new Correctness(
-				(Base == Base.K ? Base.B : throw CastException.ChildBase1(Base)),
+				(Base == Base.K ? Base.B : throw FragmentPropertyException.ChildBase1(Base)),
 				Input,
 				DisSatisfiable,
 				true
@@ -94,15 +94,15 @@ public override Correctness CastCheck() =>
 
 		public override Correctness CastDupIf() =>
 			new Correctness(
-				(Base == Base.V ? Base.B : throw CastException.ChildBase1(Base)),
-				(Input == Input.Zero ? Input.OneNonZero : throw CastException.NonZeroDupIf),
+				(Base == Base.V ? Base.B : throw FragmentPropertyException.ChildBase1(Base)),
+				(Input == Input.Zero ? Input.OneNonZero : throw FragmentPropertyException.NonZeroDupIf()),
 				true,
 				true
 				);
 
 		public override Correctness CastVerify() =>
 			new Correctness(
-				(Base == Base.B ? Base.V : throw CastException.ChildBase1(Base)),
+				(Base == Base.B ? Base.V : throw FragmentPropertyException.ChildBase1(Base)),
 				Input,
 				false,false
 				);
@@ -110,9 +110,9 @@ public override Correctness CastVerify() =>
 		public override Correctness CastNonZero()
 		{
 			if (Input != Input.OneNonZero && Input != Input.AnyNonZero)
-				throw CastException.NonZeroZero;
+				throw FragmentPropertyException.NonZeroZero();
 			return new Correctness(
-				(Base == Base.B ? Base.B : throw CastException.ChildBase1(Base)),
+				(Base == Base.B ? Base.B : throw FragmentPropertyException.ChildBase1(Base)),
 				Input,
 				true,
 				Unit
@@ -121,7 +121,7 @@ public override Correctness CastNonZero()
 
 		public override Correctness CastZeroNotEqual() =>
 			new Correctness(
-				(Base == Base.B ? Base.B : throw CastException.ChildBase1(Base)),
+				(Base == Base.B ? Base.B : throw FragmentPropertyException.ChildBase1(Base)),
 				Input,
 				DisSatisfiable,
 				true
@@ -129,7 +129,7 @@ public override Correctness CastZeroNotEqual() =>
 
 		public override Correctness CastTrue() =>
 			new Correctness(
-				(Base == Base.V ? Base.B : throw CastException.ChildBase1(Base)),
+				(Base == Base.V ? Base.B : throw FragmentPropertyException.ChildBase1(Base)),
 				Input,
 				false,
 				true
@@ -137,7 +137,7 @@ public override Correctness CastTrue() =>
 
 		public override Correctness CastOrIFalse() =>
 			new Correctness(
-				(Base == Base.B ? Base.B : throw CastException.ChildBase1(Base)),
+				(Base == Base.B ? Base.B : throw FragmentPropertyException.ChildBase1(Base)),
 				(Input == Input.Zero ? Input.One : Input.Any),
 				true,
 				Unit
@@ -145,7 +145,7 @@ public override Correctness CastOrIFalse() =>
 
 		public override Correctness AndB(Correctness l, Correctness r) =>
 			new Correctness(
-				((l.Base == Base.B && r.Base == Base.W) ? Base.B : throw CastException.ChildBase2(l.Base, r.Base) ),
+				((l.Base == Base.B && r.Base == Base.W) ? Base.B : throw FragmentPropertyException.ChildBase2(l.Base, r.Base) ),
 
 				(l.Input == Input.Zero && r.Input == Input.Zero) ? Input.Zero :
 				((l.Input == Input.Zero && r.Input == Input.One)
@@ -164,7 +164,7 @@ public override Correctness AndV(Correctness l, Correctness r)
 			return new Correctness(
 				(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 : throw CastException.ChildBase2(l.Base, r.Base),
+				(l.Base == Base.V && r.Base == Base.V) ? Base.V : throw FragmentPropertyException.ChildBase2(l.Base, r.Base),
 
 				(l.Input == Input.Zero && r.Input == Input.Zero) ? Input.Zero :
 				(l.Input == Input.Zero && r.Input == Input.One) ||
@@ -183,11 +183,11 @@ public override Correctness AndV(Correctness l, Correctness r)
 		public override Correctness OrB(Correctness l, Correctness r)
 		{
 			if (!l.DisSatisfiable)
-				throw CastException.LeftNotDissatisfiable;
+				throw FragmentPropertyException.LeftNotDissatisfiable();
 			if (!r.DisSatisfiable)
-				throw CastException.RightNotDissatisfiable;
+				throw FragmentPropertyException.RightNotDissatisfiable();
 			return new Correctness(
-				(l.Base == Base.B && r.Base == Base.W) ? Base.B : throw CastException.ChildBase2(l.Base, r.Base),
+				(l.Base == Base.B && r.Base == Base.W) ? Base.B : throw FragmentPropertyException.ChildBase2(l.Base, r.Base),
 				(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) ||
@@ -202,11 +202,11 @@ public override Correctness OrB(Correctness l, Correctness r)
 		public override Correctness OrD(Correctness l, Correctness r)
 		{
 			if (!l.DisSatisfiable)
-				throw CastException.LeftNotDissatisfiable;
+				throw FragmentPropertyException.LeftNotDissatisfiable();
 			if (!l.Unit)
-				throw CastException.LeftNotUnit;
+				throw FragmentPropertyException.LeftNotUnit();
 			return new Correctness(
-				(l.Base == Base.B) ? Base.B : throw CastException.ChildBase2(l.Base, r.Base),
+				(l.Base == Base.B) ? Base.B : throw FragmentPropertyException.ChildBase2(l.Base, r.Base),
 				(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 :
@@ -219,15 +219,15 @@ public override Correctness OrD(Correctness l, Correctness r)
 		public override Correctness OrC(Correctness l, Correctness r)
 		{
 			if (!l.DisSatisfiable)
-				throw CastException.LeftNotDissatisfiable;
+				throw FragmentPropertyException.LeftNotDissatisfiable();
 			if (!l.Unit)
-				throw CastException.LeftNotUnit;
+				throw FragmentPropertyException.LeftNotUnit();
 
 			return
 				new Correctness(
 					(l.Base == Miniscript.Base.B && r.Base == Miniscript.Base.V)
 						? Miniscript.Base.V
-						: throw CastException.ChildBase2(l.Base, r.Base),
+						: throw FragmentPropertyException.ChildBase2(l.Base, r.Base),
 					Miniscript.Input.Any,
 					false,
 					false
@@ -238,7 +238,7 @@ public override Correctness OrI(Correctness l, Correctness r) =>
 			new Correctness(
 				(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 : throw CastException.ChildBase2(l.Base, r.Base),
+				(l.Base == Miniscript.Base.K && r.Base == Miniscript.Base.K) ? Miniscript.Base.K : throw FragmentPropertyException.ChildBase2(l.Base, r.Base),
 				(l.Input == Miniscript.Input.Zero && r.Input == Miniscript.Input.Zero) ? Miniscript.Input.One : Miniscript.Input.Any,
 				(l.DisSatisfiable || r.DisSatisfiable),
 				l.Unit && r.Unit
@@ -247,14 +247,14 @@ public override Correctness OrI(Correctness l, Correctness r) =>
 		public override Correctness AndOr(Correctness a, Correctness b, Correctness c)
 		{
 			if (!a.DisSatisfiable)
-				throw CastException.LeftNotDissatisfiable;
+				throw FragmentPropertyException.LeftNotDissatisfiable();
 			if (!a.Unit)
-				throw CastException.LeftNotUnit;
+				throw FragmentPropertyException.LeftNotUnit();
 			return new Correctness(
 				(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 :
-					throw CastException.ChildBase3(a.Base, b.Base, c.Base),
+					throw FragmentPropertyException.ChildBase3(a.Base, b.Base, c.Base),
 				(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) ||
@@ -279,17 +279,17 @@ public override Correctness Threshold(int k, int n, Func<int, Correctness> subCk
 				{
 					isN &= subType.Input == Input.OneNonZero || subType.Input == Input.AnyNonZero;
 					if (subType.Base != Base.B)
-						throw CastException.ThresholdBase(0U, subType.Base);
+						throw FragmentPropertyException.ThresholdBase(0U, subType.Base);
 				}
 				else
 				{
 					if (subType.Base != Miniscript.Base.W)
-						throw CastException.ThresholdBase((uint)n, subType.Base);
+						throw FragmentPropertyException.ThresholdBase((uint)n, subType.Base);
 				}
 				if (!subType.Unit)
-					throw CastException.ThresholdNonUnit((uint)n);
+					throw FragmentPropertyException.ThresholdNonUnit((uint)n);
 				if (!subType.DisSatisfiable)
-					throw CastException.ThresholdDissat((uint)n);
+					throw FragmentPropertyException.ThresholdDissat((uint)n);
 			}
 			return new Correctness(
 				Base.B,
diff --git a/NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs b/NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs
new file mode 100644
index 0000000000..0b4ec3beb9
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs
@@ -0,0 +1,166 @@
+using System;
+using System.Linq;
+
+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,
+	}
+	class FragmentPropertyException : Exception
+	{
+		public readonly ErrorKind Kind;
+		public FragmentPropertyException(string msg, Exception innerException): base(msg, innerException) {}
+
+		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 (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);
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
index cebfe7fc67..4542be3996 100644
--- a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Linq;
 using NBitcoin.Scripting.Miniscript.Policy;
 
 namespace NBitcoin.Scripting.Miniscript.Types
@@ -55,177 +54,4 @@ public virtual void SanityChecks() {}
 		public abstract T Threshold(int k, int n, Func<int, T> subCk);
 		#endregion
 	}
-
-	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
-	}
-
-	internal enum CastErrorKind
-	{
-
-		/// <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 CastException : InvalidCastException
-	{
-		internal CastErrorKind Kind;
-
-		private CastException(CastErrorKind e, string msg) : base(
-			$"Failed to cast. kind {e.ToString("G")}. msg: {msg} ")
-		{
-			Kind = e;
-		}
-
-		public static CastException LeftNotUnit =
-			new CastException(CastErrorKind.LeftNotUnit, "this fragment requires left to be unit. But it was not.");
-
-		public static CastException ChildBase1(Base b) =>
-			new CastException(CastErrorKind.ChildBase1, $"Attempted to construct a wrapper. But the child had an invalid type {b.ToString("G")}");
-		public static CastException ChildBase2(Base l, Base r) =>
-			new CastException(CastErrorKind.ChildBase2, $"Attempted to construct a wrapper. But the child had an invalid type. left: {l.ToString("G")}. right: {r.ToString("G")}");
-
-		public static CastException ChildBase3(Base a, Base b, Base c) =>
-			new CastException(CastErrorKind.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")}");
-
-		public static CastException SwapNoneOne =
-			new CastException(CastErrorKind.SwapNonOne, "Tried to use the s: modifier for the fragment takes more than one output.");
-
-		public static CastException NonZeroDupIf =
-			new CastException(CastErrorKind.NonZeroDupIf, $"Passed a z argument to a d wrapper when `z` was expected.");
-
-		public static CastException NonZeroZero =
-			new CastException(CastErrorKind.NonZeroZero, "Tried to use `s:` modifier on a fragment that takes more than one input");
-		public static CastException LeftNotDissatisfiable =
-			new CastException(CastErrorKind.LeftNotDissatisfiable, "Left child must be dissatisfiable");
-		public static CastException RightNotDissatisfiable =
-			new CastException(CastErrorKind.RightNotDissatisfiable, "Right child must be dissatisfiable.");
-
-		public static CastException ThresholdBase(uint i, Base b) =>
-			new CastException(CastErrorKind.ThresholdBase,
-				$"the {i}th value of the threshold fragment had an invalid type (first must be `B` and rest must be `W`.)");
-
-		public static CastException ThresholdNonUnit(uint n) =>
-			new CastException(CastErrorKind.ThresholdNonUnit, "the {n} th fragment of the threshold was not the unit");
-
-		public static CastException ThresholdDissat(uint n) =>
-			new CastException(CastErrorKind.ThresholdDissat, $"the {n}th child of the threshold did not have unique satisfaction");
-	}
-
-	class TypeCheckException<TPk, TPKh> : Exception
-		where TPk : class, IMiniscriptKey<TPKh>, new()
-		where TPKh : class, IMiniscriptKeyHash, new()
-	{
-		public readonly Terminal<TPk, TPKh> Fragment;
-		public readonly ErrorKind Kind;
-		public readonly int[] Items;
-		public TypeCheckException(Terminal<TPk, TPKh> fragment, ErrorKind kind)
-			: this(fragment, kind, new int[] { })
-		{}
-
-		public TypeCheckException(Terminal<TPk, TPKh> fragment, ErrorKind kind, int[] items):
-			base($"Error: {kind.ToString("G")}. Fragment: {fragment}, items: {items.Select(i => i.ToString()).Aggregate((str, i) => $"{str}, {i}")}")
-
-		{
-			Fragment = fragment;
-			Kind = kind;
-			Items = items;
-		}
-
-		public TypeCheckException(string msg): base(msg) {}
-		public TypeCheckException(string msg, Exception innerException): base(msg, innerException) {}
-	}
-
 }
diff --git a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
index 57fd9a2ff5..279e09bd19 100644
--- a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
@@ -27,7 +27,7 @@ public bool IsSubtype(MiniscriptFragmentType other) =>
 		public override void SanityChecks()
 		{
 			Debug.Assert(!this.Correctness.DisSatisfiable || this.Malleability.Dissat != Dissat.None);
-			Debug.Assert(this.Malleability.Dissat == Dissat.None || this.Correctness.Base != Base.K);
+			Debug.Assert(this.Malleability.Dissat == Dissat.None || this.Correctness.Base != Base.V);
 			Debug.Assert(this.Malleability.Safe || this.Correctness.Base != Base.K);
 			Debug.Assert(this.Malleability.NonMalleable || this.Correctness.Input != Input.Zero);
 		}
diff --git a/NBitcoin/Scripting/Miniscript/Types/Property.cs b/NBitcoin/Scripting/Miniscript/Types/Property.cs
index 990d4661cd..c4febbeea5 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Property.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Property.cs
@@ -54,28 +54,27 @@ T GetChild(Terminal<TPk, TPKh> sub, int n)
 				case Terminal<TPk, TPKh>.ThreshM self:
 					if (self.Item1 == 0)
 					{
-						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroThreshold);
+						throw FragmentPropertyException.ZeroThreshold(fragment.ToString());
 					}
 
 					if (self.Item1 > self.Item2.Length)
 					{
-						throw new TypeCheckException<TPk, TPKh>(
-							fragment,
-							ErrorKind.OverThreshold,
-							new int[] {(int)self.Item1, self.Item2.Length});
+						throw FragmentPropertyException.OverThreshold(
+							fragment.ToString()
+							);
 					}
 					return new T().FromMulti((int)self.Item1, self.Item2.Length);
 				case Terminal<TPk, TPKh>.After self:
 					if (self.Item == 0)
 					{
-						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroTime);
+						throw FragmentPropertyException.ZeroTime(fragment.ToString());
 					}
 
 					return new T().FromAfter(self.Item);
 				case Terminal<TPk, TPKh>.Older self:
 					if (self.Item == 0)
 					{
-						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroTime);
+						throw FragmentPropertyException.ZeroTime(fragment.ToString());
 					}
 
 					return new T().FromOlder(self.Item);
@@ -129,12 +128,12 @@ T GetChild(Terminal<TPk, TPKh> sub, int n)
 				case Terminal<TPk, TPKh>.Thresh self:
 					if (self.Item1 == 0)
 					{
-						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.ZeroThreshold);
+						throw FragmentPropertyException.ZeroThreshold(fragment.ToString());
 					}
 
 					if (self.Item1 > self.Item2.Length)
 					{
-						throw new TypeCheckException<TPk, TPKh>(fragment, ErrorKind.OverThreshold);
+						throw FragmentPropertyException.OverThreshold(fragment.ToString());
 					}
 					return
 						new T().Threshold((int)self.Item1, self.Item2.Length, (n) =>

From 0682061cc016cf98d0bafe6bc36b80a142e2fbc1 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Thu, 7 Nov 2019 23:43:31 +0900
Subject: [PATCH 12/50] Fix bug in Or expression parser

---
 NBitcoin.Tests/MiniscriptTests.cs                          | 7 ++++---
 .../Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs      | 6 ++++--
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index a65fee219f..4f13817029 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -214,9 +214,8 @@ public void PolicyParserTest()
 
 			var strOr = $"or(99@pk({PubKeys[0]}),pk({PubKeys[1]}))";
 			// var strOr = $"or(pk({PubKeys[0]}),pk({PubKeys[1]}))";
-			// var msRealOr = ConcretePolicy<PubKey, uint160>.Parse(strOr);
-			var msRealOr = MiniscriptDSLParser<PubKey, uint160>.PSubExprs("or", MiniscriptDSLParser<PubKey, uint160>.POrWithProb).Parse(strOr);
-			// Assert.True(msRealOr.IsValid());
+			var msRealOr = ConcretePolicy<PubKey, uint160>.Parse(strOr);
+			Assert.True(msRealOr.IsValid());
 		}
 
 		[Fact]
@@ -225,9 +224,11 @@ public void MiniscriptParserTest()
 		{
 			var pkStr = $"c:pk({PubKeys[0]})";
 			var orStr = $"or_b(c:pk({PubKeys[0]}),sc:pk({PubKeys[1]}))";
+			var andStr = $"and(time(3),{orStr})";
 			// var orMs = Miniscript<PubKey, uint160>.Parse(orStr);
 			var pkRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(pkStr);
 			var orRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(orStr);
+			var andRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(andStr);
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
index badc53e9ca..150a637700 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
@@ -117,6 +117,7 @@ from identifier in Parse.String(name)
 			from x in SurroundedByBrackets()
 			select x;
 
+		# region leaf
 		private static Parser<char, ConcretePolicy<TPk, TPKh>> PPubKeyExpr()
 			=>
 			from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
@@ -152,6 +153,8 @@ private static Parser<char, ConcretePolicy<TPk, TPKh>> POlderExpr()
 			from t in ExprP("older").Then(s => TryConvert(s, UInt32.Parse))
 			select ConcretePolicy<TPk, TPKh>.NewOlder(t);
 
+		# endregion
+
 		internal static Parser<char, IEnumerable<TSub>> PSubExprs<TSub>(string name, Func<Parser<char, TSub>> subP) =>
 			from _n in Parse.String(name)
 			from _left in Parse.Char('(')
@@ -182,8 +185,7 @@ from sub in Parse.Ref(DSLParser)
 		internal static Parser<char, ConcretePolicy<TPk, TPKh>> POrExpr()
 			=>
 			from x in
-				PSubExprs("or", POrWithProb)
-				.Or(PSubExprs("or", POrWithoutProb))
+				PSubExprs("or",  () => POrWithProb().Or(POrWithoutProb()))
 			select ConcretePolicy<TPk, TPKh>.NewOr(x);
 
 		private static Parser<char, T> PThresh<T, TIn>(

From 7f3f8ef2911c3f722cdacb524c7845a7d5bb417c Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Fri, 8 Nov 2019 00:54:51 +0900
Subject: [PATCH 13/50] Pass ConcretePolicy parser test

---
 NBitcoin.Tests/MiniscriptTests.cs             | 18 +++++++-
 .../MiniscriptDSLParsers.ConcretePolicy.cs    | 46 -------------------
 2 files changed, 16 insertions(+), 48 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 4f13817029..3f30847f25 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -214,8 +214,22 @@ public void PolicyParserTest()
 
 			var strOr = $"or(99@pk({PubKeys[0]}),pk({PubKeys[1]}))";
 			// var strOr = $"or(pk({PubKeys[0]}),pk({PubKeys[1]}))";
-			var msRealOr = ConcretePolicy<PubKey, uint160>.Parse(strOr);
-			Assert.True(msRealOr.IsValid());
+			var orRes = ConcretePolicy<PubKey, uint160>.Parse(strOr);
+			Assert.True(orRes.IsValid());
+
+			var strNestedOr = $"or(after(3),{strOr})";
+			var nestedOrRes = ConcretePolicy<PubKey, uint160>.Parse(strNestedOr);
+			Assert.True(nestedOrRes.IsValid());
+
+			var strAnd = $"and(older(3),{strNestedOr})";
+			var andRes = ConcretePolicy<PubKey, uint160>.Parse(strAnd);
+			Assert.True(andRes.IsValid());
+
+			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.IsValid());
 		}
 
 		[Fact]
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
index 150a637700..f0ec9049aa 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
@@ -20,52 +20,6 @@ from x in Parse.CharExcept(')').Many().Text()
 				from rightB in Parse.Char(')').Token()
 				select x;
 
-		private static string[] SafeSplit(string s)
-		{
-			var parenthCount = 0;
-			var items = new List<string>();
-			var charSoFar = new List<char>();
-			var length = s.Length;
-			for (int i = 0; i < length; i++)
-			{
-				var c = s[i];
-				if (c == '(')
-				{
-					parenthCount++;
-					charSoFar.Add(c);
-				}
-				else if (c == ')')
-				{
-					parenthCount--;
-					charSoFar.Add(c);
-				}
-				else if (parenthCount != 0)
-				{
-					charSoFar.Add(c);
-				}
-
-				if (parenthCount == 0)
-				{
-					if (i == length - 1)
-					{
-						charSoFar.Add(c);
-					}
-					if (c == ',' || i == length - 1)
-					{
-						var charsCopy = new List<char>(charSoFar);
-						charSoFar = new List<char>();
-						var item = new String(charsCopy.ToArray()).Trim();
-						items.Add(item);
-					}
-					else
-					{
-						charSoFar.Add(c);
-					}
-				}
-			}
-			return items.ToArray();
-		}
-
 		internal static Parser<char, T> TryConvert<T>(string str, Func<string, T> converter)
 		{
 			return i =>

From 0129c3a1a4a927f4061b7823a749b5d5899cfe40 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Fri, 8 Nov 2019 21:42:43 +0900
Subject: [PATCH 14/50] Modify GetChild

---
 NBitcoin/Scripting/Miniscript/Types/Property.cs | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/NBitcoin/Scripting/Miniscript/Types/Property.cs b/NBitcoin/Scripting/Miniscript/Types/Property.cs
index c4febbeea5..52329fd91d 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Property.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Property.cs
@@ -28,14 +28,10 @@ private static T TypeCheckCore(Terminal<TPk, TPKh> fragment,Func<int, T> child)
 		{
 			T GetChild(Terminal<TPk, TPKh> sub, int n)
 				{
-					try
-					{
-						return child(n);
-					}
-					catch
-					{
-						return TypeCheck(sub, _ => null);
-					}
+						var r = child(n);
+						if (r is null)
+							return TypeCheck(sub, _ => null);
+						return r;
 				}
 			switch (fragment.Tag)
 			{

From 2c0d72e0e16a984d72ba611020e81ef6643e6633 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Fri, 8 Nov 2019 21:49:42 +0900
Subject: [PATCH 15/50] Update Terminal Parser

---
 NBitcoin.Tests/MiniscriptTests.cs             |  4 +-
 NBitcoin/Scripting/Miniscript/AstElem.cs      | 28 ++++++++--
 .../MiniscriptDSLParser.Terminal.cs           | 53 +++++++++++--------
 .../Scripting/Miniscript/Types/Property.cs    |  4 ++
 4 files changed, 62 insertions(+), 27 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 3f30847f25..e0d3afd2f5 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -238,11 +238,11 @@ public void MiniscriptParserTest()
 		{
 			var pkStr = $"c:pk({PubKeys[0]})";
 			var orStr = $"or_b(c:pk({PubKeys[0]}),sc:pk({PubKeys[1]}))";
-			var andStr = $"and(time(3),{orStr})";
+			// var andStr = $"";
 			// var orMs = Miniscript<PubKey, uint160>.Parse(orStr);
 			var pkRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(pkStr);
 			var orRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(orStr);
-			var andRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(andStr);
+			// var andRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(andStr);
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 5cd21d73bf..6108002b34 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -314,7 +314,14 @@ public ThreshM(uint item1, TPk[] item2): base(Tags.ThreshM)
 
 		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) => new Pk(item);
+		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);
@@ -328,7 +335,14 @@ 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) => new Terminal<TPk, TPKh>.Check(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);
@@ -344,7 +358,15 @@ public static Terminal<TPk, TPKh> NewAndOr(Miniscript<TPk, TPKh> item1, Miniscri
 			=> new AndOr(item1, item2, item3);
 
 		public static Terminal<TPk, TPKh> NewOrB(Miniscript<TPk, TPKh> item1, Miniscript<TPk, TPKh> item2)
-			=> new OrB(item1, 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);
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
index 3c0e644c18..6c40863ad4 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
@@ -53,16 +53,20 @@ from t in ExprP("hash160").Then(s => TryConvert(s, uint160.Parse))
 		private static Parser<char, Terminal<TPk, TPKh>> PWrapper(char identifier,
 			Func<Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> construct)
 			=>
-				from _t in Parse.Char(identifier).Then(_ => Parse.Char(':'))
-				from inner in Parse.Ref(() => TerminalDSLParser)
-					.Except(PWrapper(identifier, construct)) // should not have the same wrapper twice
-				select construct(Miniscript<TPk, TPKh>.FromAst(inner));
+				(from _t in Parse.Char(identifier).Then(_ => Parse.Char(':'))
+				from inner in Parse.Ref(PNonWrappers)
+				select construct(Miniscript<TPk, TPKh>.FromAst(inner)))
+				.Or(
+					from _t in Parse.Char(identifier)
+					from x in Parse.Ref(() => PWrappers).Except(PWrapper(identifier, construct))
+					select x
+					);
 
 		private static Parser<char, Terminal<TPk, TPKh>> PBinary(
 			string identifier,
 			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> constructor
 		) =>
-			from s in PSubExprs(identifier, () => TerminalDSLParser)
+			from s in PSubExprs(identifier, TerminalDSLParser)
 			where s.Count() == 2
 			select constructor(Miniscript<TPk, TPKh>.FromAst(s.ElementAt(0)),
 				Miniscript<TPk, TPKh>.FromAst(s.ElementAt(1)));
@@ -71,7 +75,7 @@ private static Parser<char, Terminal<TPk, TPKh>> PTernary(
 			string identifier,
 			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> constructor
 		) =>
-			from s in PSubExprs(identifier, () => TerminalDSLParser)
+			from s in PSubExprs(identifier, TerminalDSLParser)
 			where s.Count() == 3
 			select constructor(
 				Miniscript<TPk, TPKh>.FromAst(s.ElementAt(0)),
@@ -82,30 +86,31 @@ select constructor(
 			PThresh(
 				"thresh",
 				Terminal<TPk, TPKh>.NewThresh,
-				() => TerminalDSLParser.Select(t => Miniscript<TPk, TPKh>.FromAst(t)));
+				() => TerminalDSLParser().Select(t => Miniscript<TPk, TPKh>.FromAst(t)));
 
 		private static Parser<char, Terminal<TPk, TPKh>> PTerminalThreshM =
 			PThresh("thresh_m", Terminal<TPk, TPKh>.NewThreshM,
 			() => (from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
 			select pk));
 
-		private static readonly Parser<char, Terminal<TPk, TPKh>> TerminalDSLParser =
-			// ------ leafs ------
-			Parse.Ref(() => PTerminalPk)
-				.Or(Parse.Ref(() => PTerminalPkH))
-				.Or(Parse.Ref(() => PTerminalAfter))
-				.Or(Parse.Ref(() => PTerminalOlder))
-				.Or(Parse.Ref(() => PTerminalSha256))
-				.Or(Parse.Ref(() => PTerminalHash256))
-				.Or(Parse.Ref(() => PTerminalRipemd160))
-				.Or(Parse.Ref(() => PTerminalHash160))
-				// ------- wrappers --------
-				.Or(PWrapper('a', Terminal<TPk, TPKh>.NewAlt))
-				.Or(PWrapper('s', Terminal<TPk, TPKh>.NewSwap))
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PWrappers =
+				PWrapper('a', Terminal<TPk, TPKh>.NewAlt)
 				.Or(PWrapper('c', Terminal<TPk, TPKh>.NewCheck))
+				.Or(PWrapper('s', Terminal<TPk, TPKh>.NewSwap))
 				.Or(PWrapper('d', Terminal<TPk, TPKh>.NewDupIf))
 				.Or(PWrapper('v', Terminal<TPk, TPKh>.NewVerify))
-				.Or(PWrapper('j', Terminal<TPk, TPKh>.NewZeroNotEqual))
+				.Or(PWrapper('j', Terminal<TPk, TPKh>.NewZeroNotEqual));
+
+		private static Parser<char, Terminal<TPk, TPKh>> PNonWrappers() =>
+			// ------ leafs ------
+			PTerminalPk
+				.Or(PTerminalPkH)
+				.Or(PTerminalAfter)
+				.Or(PTerminalOlder)
+				.Or(PTerminalSha256)
+				.Or(PTerminalHash256)
+				.Or(PTerminalRipemd160)
+				.Or(PTerminalHash160)
 				// ------- Conjunctions -----
 				.Or(PBinary("and_v", Terminal<TPk, TPKh>.NewAndV))
 				.Or(PBinary("and_b", Terminal<TPk, TPKh>.NewAndB))
@@ -118,8 +123,12 @@ select constructor(
 				// ------- Thresholds ------
 				.Or(Parse.Ref(() => PTerminalThresh))
 				.Or(Parse.Ref(() => PTerminalThreshM));
+		private static Parser<char, Terminal<TPk, TPKh>> TerminalDSLParser() =>
+				Parse.Ref(() => PWrappers)
+					.Or(PNonWrappers());
+				// ------- wrappers --------
 
 		public static Terminal<TPk, TPKh> ParseTerminal(string input)
-			=> Parse.Ref(() => TerminalDSLParser).Parse(input);
+			=> TerminalDSLParser().Parse(input);
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Types/Property.cs b/NBitcoin/Scripting/Miniscript/Types/Property.cs
index 52329fd91d..718adb9043 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Property.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Property.cs
@@ -26,6 +26,9 @@ internal static T TypeCheck(Terminal<TPk, TPKh> fragment)
 
 		private static T TypeCheckCore(Terminal<TPk, TPKh> fragment,Func<int, T> child)
 		{
+			if (fragment is null)
+				throw new ArgumentNullException(nameof(fragment));
+
 			T GetChild(Terminal<TPk, TPKh> sub, int n)
 				{
 						var r = child(n);
@@ -33,6 +36,7 @@ T GetChild(Terminal<TPk, TPKh> sub, int n)
 							return TypeCheck(sub, _ => null);
 						return r;
 				}
+
 			switch (fragment.Tag)
 			{
 				case Terminal<TPk, TPKh>.Tags.True:

From 7f795c4bb288d08cb1601bcf72e37ecec2d5b05f Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Fri, 8 Nov 2019 21:56:53 +0900
Subject: [PATCH 16/50] Add assertion to check contents after parsing

---
 NBitcoin.Tests/MiniscriptTests.cs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index e0d3afd2f5..388bd826df 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -241,7 +241,10 @@ public void MiniscriptParserTest()
 			// var andStr = $"";
 			// var orMs = Miniscript<PubKey, uint160>.Parse(orStr);
 			var pkRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(pkStr);
+			Assert.True(pkRes is Terminal<PubKey, uint160>.Check c && (c.Item.Node is Terminal<PubKey, uint160>.Pk));
+
 			var orRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(orStr);
+			Assert.True(orRes is Terminal<PubKey, uint160>.OrB);
 			// var andRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(andStr);
 		}
 	}

From 464c87074f6432068ef610ff7d9de0969b864748 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sat, 9 Nov 2019 18:42:15 +0900
Subject: [PATCH 17/50] Prepare Terminal.ToString and ToDebugSTring

---
 NBitcoin.Tests/MiniscriptTests.cs             |   3 +-
 NBitcoin/Scripting/Miniscript/AstElem.cs      | 294 +++++++++++++++++-
 NBitcoin/Scripting/Miniscript/Input.cs        |  28 +-
 .../Scripting/Miniscript/InputExtensions.cs   |  22 --
 NBitcoin/Scripting/Miniscript/Miniscript.cs   |   7 +
 .../MiniscriptDSLParser.Terminal.cs           |  18 +-
 .../Miniscript/Types/Malleability.cs          |   5 +
 7 files changed, 347 insertions(+), 30 deletions(-)
 delete mode 100644 NBitcoin/Scripting/Miniscript/InputExtensions.cs

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 388bd826df..12ca97f573 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -244,7 +244,8 @@ public void MiniscriptParserTest()
 			Assert.True(pkRes is Terminal<PubKey, uint160>.Check c && (c.Item.Node is Terminal<PubKey, uint160>.Pk));
 
 			var orRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(orStr);
-			Assert.True(orRes is Terminal<PubKey, uint160>.OrB);
+			Console.WriteLine(orRes.ToString());
+			Assert.True(orRes is Terminal<PubKey, uint160>.OrB orb && (orb.Item2.Node is Terminal<PubKey, uint160>.Swap));
 			// var andRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(andStr);
 		}
 	}
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 6108002b34..a729372c6f 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Text;
+using NBitcoin.Scripting.Miniscript.Types;
 
 namespace NBitcoin.Scripting.Miniscript
 {
@@ -91,6 +93,7 @@ public bool Equals(NonTerm other)
 		#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()
@@ -999,6 +1002,295 @@ public int MaxSatisfactionSize(int oneCost)
 			}
 			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>
+		/// <param name="???"></param>
+		/// <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:
+					if (!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:
+					if (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)
+		{
+			sb.Append("[");
+			try
+			{
+				var typeMap = Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(this);
+				sb.Append(typeMap.Correctness.Base);
+				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');
+			}
+			catch (FragmentPropertyException)
+			{
+				sb.Append("TYPECHECK FAILED");
+			}
+			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!");
+		}
+	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Input.cs b/NBitcoin/Scripting/Miniscript/Input.cs
index 8ed0cca25d..b0e0f2ea97 100644
--- a/NBitcoin/Scripting/Miniscript/Input.cs
+++ b/NBitcoin/Scripting/Miniscript/Input.cs
@@ -4,7 +4,7 @@ namespace NBitcoin.Scripting.Miniscript
 	/// Type property representing exceptions about how many inputs
 	/// the fragment accepts, and assumptions about that.
 	/// </summary>
-	public enum Input
+	internal enum Input
 	{
 		Zero,
 		One,
@@ -12,4 +12,30 @@ public enum Input
 		OneNonZero,
 		AnyNonZero
 	}
+
+	internal static class InputExtension
+	{
+		public static string DebugPrint(this Input i)
+			=> (i == Input.Zero) ? "z" :
+				(i == Input.One) ? "0" :
+				(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/InputExtensions.cs b/NBitcoin/Scripting/Miniscript/InputExtensions.cs
deleted file mode 100644
index 85dce15a06..0000000000
--- a/NBitcoin/Scripting/Miniscript/InputExtensions.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-namespace NBitcoin.Scripting.Miniscript
-{
-	public static partial class InputExtensions
-	{
-		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;
-		}
-	}
-}
\ No newline at end of file
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index 8136a86baf..fea321ef72 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -1,8 +1,10 @@
 using System;
+using System.Diagnostics;
 using NBitcoin.Scripting.Miniscript.Types;
 
 namespace NBitcoin.Scripting.Miniscript
 {
+	[DebuggerDisplay("{" + nameof(ToDebugString) + "()}")]
 	public partial class Miniscript<TPk, TPKh>
 		where TPk : class, IMiniscriptKey<TPKh>, new()
 		where TPKh : class, IMiniscriptKeyHash, new()
@@ -46,5 +48,10 @@ public static Miniscript<TPk, TPKh> Parse(string str)
 		public Script ToScript() =>
 			Node.ToScript();
 
+		public override string ToString()
+			=> this.Node.ToString();
+
+		public string ToDebugString() =>
+			Node.ToDebugString();
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
index 6c40863ad4..730278b79c 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
@@ -21,9 +21,13 @@ from pkH in ExprP("pk_h").Then(TryParseMiniscriptKeyHash)
 			select Terminal<TPk, TPKh>.NewPkH(pkH);
 
 		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalTrue =
-			from _t in Parse.Char('0').Token()
+			from _t in Parse.Char('1').Token()
 			select Terminal<TPk, TPKh>.NewTrue();
 
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalFalse =
+			from _t in Parse.Char('0').Token()
+			select Terminal<TPk, TPKh>.NewFalse();
+
 		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalAfter =
 			from t in ExprP("after").Then(s => TryConvert(s, UInt32.Parse))
 			select Terminal<TPk, TPKh>.NewAfter(t);
@@ -53,13 +57,15 @@ from t in ExprP("hash160").Then(s => TryConvert(s, uint160.Parse))
 		private static Parser<char, Terminal<TPk, TPKh>> PWrapper(char identifier,
 			Func<Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> construct)
 			=>
-				(from _t in Parse.Char(identifier).Then(_ => Parse.Char(':'))
-				from inner in Parse.Ref(PNonWrappers)
-				select construct(Miniscript<TPk, TPKh>.FromAst(inner)))
-				.Or(
+				(
 					from _t in Parse.Char(identifier)
 					from x in Parse.Ref(() => PWrappers).Except(PWrapper(identifier, construct))
 					select x
+				)
+				.Or(
+					from _t in Parse.Char(identifier).Then(_ => Parse.Char(':'))
+					from inner in Parse.Ref(PNonWrappers)
+					select construct(Miniscript<TPk, TPKh>.FromAst(inner))
 					);
 
 		private static Parser<char, Terminal<TPk, TPKh>> PBinary(
@@ -111,6 +117,8 @@ private static Parser<char, Terminal<TPk, TPKh>> PNonWrappers() =>
 				.Or(PTerminalHash256)
 				.Or(PTerminalRipemd160)
 				.Or(PTerminalHash160)
+				.Or(PTerminalTrue)
+				.Or(PTerminalFalse)
 				// ------- Conjunctions -----
 				.Or(PBinary("and_v", Terminal<TPk, TPKh>.NewAndV))
 				.Or(PBinary("and_b", Terminal<TPk, TPKh>.NewAndB))
diff --git a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
index 313780cbb2..b921323594 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -37,6 +37,11 @@ internal static bool IsSubType(this Dissat self, Dissat other)
 			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>

From 6ef12718ae9f115d9081103a6e45bcf105a8fc6c Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sat, 9 Nov 2019 18:54:10 +0900
Subject: [PATCH 18/50] Change order of Wrapper parser in Terminal Parser

---
 .../MiniscriptDSLParser.Terminal.cs           | 52 ++++++++++++-------
 1 file changed, 33 insertions(+), 19 deletions(-)

diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
index 730278b79c..3aef4cd79f 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
@@ -54,19 +54,23 @@ from t in ExprP("hash160").Then(s => TryConvert(s, uint160.Parse))
 
 		#endregion
 
-		private static Parser<char, Terminal<TPk, TPKh>> PWrapper(char identifier,
+		private static Parser<char, Terminal<TPk, TPKh>> PWrapperNested(char identifier,
 			Func<Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> construct)
 			=>
-				(
-					from _t in Parse.Char(identifier)
-					from x in Parse.Ref(() => PWrappers).Except(PWrapper(identifier, construct))
-					select x
-				)
-				.Or(
-					from _t in Parse.Char(identifier).Then(_ => Parse.Char(':'))
-					from inner in Parse.Ref(PNonWrappers)
-					select construct(Miniscript<TPk, TPKh>.FromAst(inner))
-					);
+			(
+				from _t in Parse.Char(identifier)
+				from x in Parse.Ref(() => PWrappersNested).Except(PWrapperNested(identifier, construct))
+				select x
+			);
+
+			private static Parser<char, Terminal<TPk, TPKh>> PWrapperInnerMost(char identifier,
+			Func<Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> construct)
+				=>
+			(
+				from _t in Parse.Char(identifier).Then(_ => Parse.Char(':'))
+				from inner in Parse.Ref(PNonWrappers)
+				select construct(Miniscript<TPk, TPKh>.FromAst(inner))
+			);
 
 		private static Parser<char, Terminal<TPk, TPKh>> PBinary(
 			string identifier,
@@ -99,13 +103,22 @@ select constructor(
 			() => (from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
 			select pk));
 
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PWrappers =
-				PWrapper('a', Terminal<TPk, TPKh>.NewAlt)
-				.Or(PWrapper('c', Terminal<TPk, TPKh>.NewCheck))
-				.Or(PWrapper('s', Terminal<TPk, TPKh>.NewSwap))
-				.Or(PWrapper('d', Terminal<TPk, TPKh>.NewDupIf))
-				.Or(PWrapper('v', Terminal<TPk, TPKh>.NewVerify))
-				.Or(PWrapper('j', Terminal<TPk, TPKh>.NewZeroNotEqual));
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PWrappersNested =
+				PWrapperNested('a', Terminal<TPk, TPKh>.NewAlt)
+				.Or(PWrapperNested('c', Terminal<TPk, TPKh>.NewCheck))
+				.Or(PWrapperNested('s', Terminal<TPk, TPKh>.NewSwap))
+				.Or(PWrapperNested('d', Terminal<TPk, TPKh>.NewDupIf))
+				.Or(PWrapperNested('v', Terminal<TPk, TPKh>.NewVerify))
+				.Or(PWrapperNested('j', Terminal<TPk, TPKh>.NewZeroNotEqual));
+
+		private static readonly Parser<char, Terminal<TPk, TPKh>> PWrappersInnerMost =
+			PWrapperInnerMost('a', Terminal<TPk, TPKh>.NewAlt)
+			.Or(PWrapperInnerMost('c', Terminal<TPk, TPKh>.NewCheck))
+			.Or(PWrapperInnerMost('s', Terminal<TPk, TPKh>.NewSwap))
+			.Or(PWrapperInnerMost('d', Terminal<TPk, TPKh>.NewDupIf))
+			.Or(PWrapperInnerMost('v', Terminal<TPk, TPKh>.NewVerify))
+			.Or(PWrapperInnerMost('j', Terminal<TPk, TPKh>.NewZeroNotEqual));
+
 
 		private static Parser<char, Terminal<TPk, TPKh>> PNonWrappers() =>
 			// ------ leafs ------
@@ -132,7 +145,8 @@ private static Parser<char, Terminal<TPk, TPKh>> PNonWrappers() =>
 				.Or(Parse.Ref(() => PTerminalThresh))
 				.Or(Parse.Ref(() => PTerminalThreshM));
 		private static Parser<char, Terminal<TPk, TPKh>> TerminalDSLParser() =>
-				Parse.Ref(() => PWrappers)
+				Parse.Ref(() => PWrappersNested)
+					.Or(Parse.Ref(() => PWrappersInnerMost))
 					.Or(PNonWrappers());
 				// ------- wrappers --------
 

From b73d8e513aa0ca640b2a846b2b3bf57e9379f0b1 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sun, 10 Nov 2019 01:03:47 +0900
Subject: [PATCH 19/50] Implement Parser without Parser Combinator

---
 NBitcoin/PubKey.cs                            |   2 +-
 NBitcoin/Scripting/Miniscript/AstElem.cs      | 180 ++++++++++++++++++
 .../Scripting/Miniscript/DSLTreeParser.cs     |   7 +
 NBitcoin/Scripting/Miniscript/Miniscript.cs   |   9 +
 .../MiniscriptDSLParsers.ConcretePolicy.cs    |   4 +-
 .../Scripting/Miniscript/MiniscriptKey.cs     |  16 +-
 NBitcoin/Scripting/Miniscript/Tree.cs         | 123 ++++++++++--
 7 files changed, 312 insertions(+), 29 deletions(-)
 create mode 100644 NBitcoin/Scripting/Miniscript/DSLTreeParser.cs

diff --git a/NBitcoin/PubKey.cs b/NBitcoin/PubKey.cs
index b048ece0e0..741392f49d 100644
--- a/NBitcoin/PubKey.cs
+++ b/NBitcoin/PubKey.cs
@@ -65,7 +65,7 @@ public static bool TryParse(string hex, out PubKey result)
 			}
 			catch
 			{
-				return true;
+				return false;
 			}
 		}
 
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index a729372c6f..d7ead959a6 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -2,8 +2,10 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Text;
 using NBitcoin.Scripting.Miniscript.Types;
+using NBitcoin.Scripting.Parser;
 
 namespace NBitcoin.Scripting.Miniscript
 {
@@ -1292,5 +1294,183 @@ private StringBuilder ToDebugStringCore(StringBuilder sb)
 
 			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(uint256.Parse(x)));
+					break;
+				case "hash256":
+					if (top.Args.Count == 1)
+						unwrapped = Tree.Terminal(top.Args[0], x => NewHash256(uint256.Parse(x.Reverse().ToString())));
+					break;
+				case "ripemd160":
+					if (top.Args.Count == 1)
+						unwrapped = Tree.Terminal(top.Args[0], x => NewRipemd160(uint160.Parse(x)));
+					break;
+				case "hash160":
+					if (top.Args.Count == 1)
+						unwrapped = Tree.Terminal(top.Args[0], x => NewHash160(uint160.Parse(x)));
+					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);
+					return NewThresh(k, subs);
+				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));
+					return NewThreshM(km, subsm);
+			}
+			if (unwrapped is null)
+				throw new ParsingException($"{top.Name}({top.Args.Count} args) while parsing Miniscript");
+
+			foreach (var ch in fragWrap.ToCharArray().Reverse())
+			{
+				switch (ch)
+				{
+					case 'a':
+						unwrapped = NewAlt(Miniscript<TPk, TPKh>.FromAst(unwrapped));
+						break;
+					case 's':
+						unwrapped = NewSwap(Miniscript<TPk, TPKh>.FromAst(unwrapped));
+						break;
+					case 'c':
+						unwrapped = NewCheck(Miniscript<TPk, TPKh>.FromAst(unwrapped));
+						break;
+					case 'd':
+						unwrapped = NewDupIf(Miniscript<TPk, TPKh>.FromAst(unwrapped));
+						break;
+					case 'v':
+						unwrapped = NewVerify(Miniscript<TPk, TPKh>.FromAst(unwrapped));
+						break;
+					case 'j':
+						unwrapped = NewNonZero(Miniscript<TPk, TPKh>.FromAst(unwrapped));
+						break;
+					case 'n':
+						unwrapped = NewZeroNotEqual(Miniscript<TPk, TPKh>.FromAst(unwrapped));
+						break;
+					case 't':
+						unwrapped = NewAndV(
+							Miniscript<TPk, TPKh>.FromAst(unwrapped),
+							Miniscript<TPk, TPKh>.FromAst(NewTrue())
+							);
+						break;
+					case 'u':
+						unwrapped = NewOrI(
+							Miniscript<TPk, TPKh>.FromAst(unwrapped),
+							Miniscript<TPk, TPKh>.FromAst(NewFalse())
+							);
+						break;
+					case 'l':
+						if (unwrapped == False)
+							throw new ParsingException($"Encountered l:o which is syntactically equal to `u:o` except stupid");
+						unwrapped = NewOrI(
+							Miniscript<TPk, TPKh>.FromAst(NewFalse()),
+							Miniscript<TPk, TPKh>.FromAst(unwrapped)
+							);
+						break;
+					default: throw new ParsingException($"Unknown wrapper {ch}");
+				}
+			}
+
+			return unwrapped;
+		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/DSLTreeParser.cs b/NBitcoin/Scripting/Miniscript/DSLTreeParser.cs
new file mode 100644
index 0000000000..f796a50b47
--- /dev/null
+++ b/NBitcoin/Scripting/Miniscript/DSLTreeParser.cs
@@ -0,0 +1,7 @@
+namespace NBitcoin.Scripting.Miniscript
+{
+	public static class DSLTreeParser
+	{
+
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index fea321ef72..e6713abf5d 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -35,6 +35,15 @@ public static Miniscript<TPk, TPKh> FromAst(Terminal<TPk, TPKh> t)
 				);
 		}
 
+		public static Miniscript<TPk, TPKh> FromTree(Tree t)
+		{
+			var inner = Terminal<TPk, TPKh>.FromTree(t);
+			return new Miniscript<TPk, TPKh>(
+				Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(inner),
+				inner,
+				Property<ExtData, TPk, TPKh>.TypeCheck(inner)
+				);
+		}
 		public static Miniscript<TPk, TPKh> Parse(string str)
 		{
 			var inner = MiniscriptDSLParser<TPk, TPKh>.ParseTerminal(str);
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
index f0ec9049aa..16cb9ae073 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
@@ -41,7 +41,7 @@ internal static Parser<char, TPk> TryParseMiniscriptKey(string str)
 				TPk t = default;
 				try
 				{
-					var k = MiniscriptKeyParser<TPk, TPKh>.TryParse(str);
+					var k = MiniscriptFragmentParser<TPk, TPKh>.ParseKey(str);
 					return ParserResult<char, TPk>.Success(i, k);
 				}
 				catch (Exception ex)
@@ -56,7 +56,7 @@ internal static Parser<char, TPKh> TryParseMiniscriptKeyHash(string str)
 				TPKh t = default;
 				try
 				{
-					var k = MiniscriptKeyParser<TPk, TPKh>.TryParseHash(str);
+					var k = MiniscriptFragmentParser<TPk, TPKh>.ParseHash(str);
 					return ParserResult<char, TPKh>.Success(i, t);
 				}
 				catch
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
index 2ffb884569..3b645b299a 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
@@ -90,26 +90,26 @@ public bool Equals(IMiniscriptKey<MiniscriptStringKeyHash> other)
 		public static MiniscriptStringKey Parse(string str)
 			=> new MiniscriptStringKey(str);
 	}
-	public static class MiniscriptKeyParser<T, TPKh>
+	public static class MiniscriptFragmentParser<TPk, TPKh>
+		where TPk : class, IMiniscriptKey<TPKh>, new()
 		where TPKh : class, IMiniscriptKeyHash, new()
-		where T : class, IMiniscriptKey<TPKh>, new()
 	{
-		public static T TryParse(string str)
+		public static TPk ParseKey(string str)
 		{
-			var t = new T();
+			var t = new TPk();
 			if (t is PubKey)
 			{
-				return new PubKey(str) as T;
+				return new PubKey(str) as TPk;
 			}
 
 			if (t is MiniscriptStringKey)
 			{
-				return MiniscriptStringKey.Parse(str) as T;
+				return MiniscriptStringKey.Parse(str) as TPk;
 			}
 			throw new NotSupportedException();
 		}
 
-		public static TPKh TryParseHash(string str)
+		public static TPKh ParseHash(string str)
 		{
 			var t = new TPKh();
 			if (t is uint160)
@@ -118,6 +118,6 @@ public static TPKh TryParseHash(string str)
 				return MiniscriptStringKeyHash.Parse(str) as TPKh;
 			throw new NotSupportedException();
 		}
-	}
 
+	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Tree.cs b/NBitcoin/Scripting/Miniscript/Tree.cs
index 20dd08a5af..9ee4be7f9a 100644
--- a/NBitcoin/Scripting/Miniscript/Tree.cs
+++ b/NBitcoin/Scripting/Miniscript/Tree.cs
@@ -1,43 +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>
-	/// <typeparam name="T"></typeparam>
-	public class Tree<T>
+	public class Tree
 	{
 		public readonly string Name;
-		public readonly Tree<T>[] Args;
-
-		/// <summary>
-		/// Attempts to parse a terminal expression.
-		/// </summary>
-		/// <param name="str"></param>
-		/// <returns></returns>
-		public static T Terminal(Tree<T> term, Func<string, T> converter)
+		public readonly List<Tree> Args;
+
+		public Tree(string name, List<Tree> args)
 		{
-			if (term.Args.Length == 0)
-				converter.Invoke(term.Name);
-			throw new ParsingException(term.Name);
+			Name = name;
+			Args = args;
 		}
 
-		public static Tree<T> Parse(string str)
+
+		public static Tree Parse(string str)
 		{
 			var topAndRemaining = FromSlice(str);
 			var top = topAndRemaining.Item1;
 			var remaining = topAndRemaining.Item2;
 			if (remaining.Length == 0)
-				throw new NotImplementedException();
-			else
-				throw new ParsingException(remaining);
+				return top;
+			throw new ParsingException($"There was remaining input after parsing. Remaining: {remaining}");
 		}
 
-		private static Tuple<Tree<T>, string> FromSlice(string str)
+		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};
+				if (ch == ',') found = new { Found = Found.Comma, Pos = n};
+				if (ch == ')') found = new { Found = Found.RParen, Pos = n};
+			}
+
+			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);
+		}
 	}
 }

From 9f4cbccff2a2ed409aa9401543be4a59d4afb7ab Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sun, 10 Nov 2019 14:05:18 +0900
Subject: [PATCH 20/50] Prepare generator for ConcretePolicy

---
 .../Generators/ConcretePolicyGenerator.cs     | 100 ++++++++++++++++++
 .../PropertyTest/MiniscriptPropertyTests.cs   |  22 ++++
 .../Miniscript/Policy/AbstractPolicy.cs       |   4 +-
 .../Miniscript/Policy/ConcretePolicy.cs       |   2 +-
 4 files changed, 125 insertions(+), 3 deletions(-)
 create mode 100644 NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
 create mode 100644 NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs

diff --git a/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs b/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
new file mode 100644
index 0000000000..777f74e9d6
--- /dev/null
+++ b/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
@@ -0,0 +1,100 @@
+using System;
+using System.Threading;
+using FsCheck;
+using NBitcoin.Scripting.Miniscript;
+using NBitcoin.Scripting.Miniscript.Policy;
+
+namespace NBitcoin.Tests.Generators
+{
+	public class ConcretePolicyGenerator<TPk, TPKh>
+	where TPk : class, IMiniscriptKey<TPKh>, new()
+	where TPKh : class, IMiniscriptKeyHash, new()
+	{
+		public static readonly Arbitrary<ConcretePolicy<TPk, TPKh>> ConcretePolicyArb
+			= new ArbitraryConcretePolicy();
+
+		public class ArbitraryConcretePolicy : Arbitrary<ConcretePolicy<TPk, TPKh>>
+		{
+			public override Gen<ConcretePolicy<TPk, TPKh>> Generator => Gen.Sized(ConcretePolicyGen);
+
+			private static Gen<ConcretePolicy<TPk, TPKh>> ConcretePolicyGen(int size)
+			{
+				if (size == 0) return NonRecursivePolicyGen();
+				return Gen.Frequency(
+					Tuple.Create(3, NonRecursivePolicyGen()),
+					Tuple.Create(2, RecursivePolicyGen(size))
+					);
+			}
+
+			private static Gen<ConcretePolicy<TPk, TPKh>> NonRecursivePolicyGen()
+				=> Gen.OneOf(new[]
+				{
+					KeyGen(),
+					AfterGen(),
+					OlderGen(),
+					Sha256Gen(),
+					Hash256Gen(),
+					Ripemd160Gen(),
+					Hash160Gen()
+				});
+
+			private static Gen<ConcretePolicy<TPk, TPKh>> KeyGen()
+				=>
+					from inner in Arb.Generate<TPk>()
+					select ConcretePolicy<TPk, TPKh>.NewKey(inner);
+
+			private static Gen<ConcretePolicy<TPk, TPKh>> AfterGen()
+				=>
+					from t in Arb.Generate<uint>()
+					select ConcretePolicy<TPk, TPKh>.NewAfter(t);
+			private static Gen<ConcretePolicy<TPk, TPKh>> OlderGen()
+				=>
+					from t in Arb.Generate<uint>()
+					select ConcretePolicy<TPk, TPKh>.NewOlder(t);
+
+			private static Gen<ConcretePolicy<TPk, TPKh>> Sha256Gen()
+				=>
+					from t in CryptoGenerator.Hash256()
+					select ConcretePolicy<TPk, TPKh>.NewSha256(t);
+
+			private static Gen<ConcretePolicy<TPk, TPKh>> Hash256Gen()
+				=>
+					from t in CryptoGenerator.Hash256()
+					select ConcretePolicy<TPk, TPKh>.NewHash256(t);
+
+			private static Gen<ConcretePolicy<TPk, TPKh>> Ripemd160Gen()
+				=>
+					from t in CryptoGenerator.Hash160()
+					select ConcretePolicy<TPk, TPKh>.NewRipemd160(t);
+
+			private static Gen<ConcretePolicy<TPk, TPKh>> Hash160Gen()
+				=>
+					from t in CryptoGenerator.Hash160()
+					select ConcretePolicy<TPk, TPKh>.NewHash160(t);
+
+			private static Gen<ConcretePolicy<TPk, TPKh>> RecursivePolicyGen(int size)
+				=>
+					Gen.OneOf(
+					(from sub in ConcretePolicyGen(size).Two()
+					select ConcretePolicy<TPk, TPKh>.NewAnd(new[] {sub.Item1, sub.Item2})),
+					(from prob in Arb.Generate<PositiveInt>().Two()
+					from sub in ConcretePolicyGen(size).Two()
+					select ConcretePolicy<TPk, TPKh>.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<TPk, TPKh>.NewThreshold(t.Item1, t.Item2))
+					);
+
+			private static Gen<Tuple<uint, ConcretePolicy<TPk, TPKh>[]>> 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/PropertyTest/MiniscriptPropertyTests.cs b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
new file mode 100644
index 0000000000..460c086f3c
--- /dev/null
+++ b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
@@ -0,0 +1,22 @@
+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<PubKey, uint160>>();
+		}
+		[Property]
+		[Trait("UnitTest", "UnitTest")]
+		public void ShouldBidirectionallyConvertConcretePolicy(ConcretePolicy<PubKey, uint160> p)
+		{}
+	}
+}
diff --git a/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
index e501a80eb5..a154422062 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
@@ -258,10 +258,10 @@ public bool Equals(AbstractPolicy<TPk, TPKh> other)
 
 		#endregion
 
-		public static AbstractPolicy<TPk, TPKh> FromTree<T>(Tree<T> top)
+		public static AbstractPolicy<TPk, TPKh> FromTree(Tree top)
 		{
 			var n = top.Name;
-			var l = top.Args.Length;
+			var l = top.Args.Count;
 			if (n == "UNSATISFIABLE" && l == 0)
 				return AbstractPolicy<TPk, TPKh>.UnSatisfiable;
 			if (n == "TRIVIAL" && l == 0)
diff --git a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
index 42508e3c7e..7539ae77fa 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
@@ -457,7 +457,7 @@ public static ConcretePolicy<TPk, TPKh> Parse(string str)
 			return MiniscriptDSLParser<TPk, TPKh>.ParseConcretePolicy(str);
 		}
 
-		private static Tuple<uint, ConcretePolicy<TPk, TPKh>> FromTreeProb<T>(Tree<T> top, bool allowProb)
+		private static Tuple<uint, ConcretePolicy<TPk, TPKh>> FromTreeProb<T>(Tree top, bool allowProb)
 		{
 			int fragProb = default;
 			string fragName = default;

From 183c52932a5e3be7e09ea1905c299960dc230210 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Tue, 12 Nov 2019 16:05:54 +0900
Subject: [PATCH 21/50] * Prepare ConcretePolicyGenerator * Pass policy parser
 tests without using Combinator

---
 .../Generators/ConcretePolicyGenerator.cs     |  61 +++---
 NBitcoin.Tests/Generators/CryptoGenerator.cs  | 200 +++++++++---------
 NBitcoin.Tests/MiniscriptTests.cs             |   8 +-
 .../PropertyTest/MiniscriptPropertyTests.cs   |  14 +-
 NBitcoin/Scripting/Miniscript/AstElem.cs      |   2 +-
 .../Miniscript/Policy/ConcretePolicy.cs       | 100 +++++++--
 NBitcoin/Scripting/Miniscript/Tree.cs         |   6 +-
 7 files changed, 233 insertions(+), 158 deletions(-)

diff --git a/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs b/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
index 777f74e9d6..e93d11bc99 100644
--- a/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
+++ b/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using FsCheck;
 using NBitcoin.Scripting.Miniscript;
@@ -6,27 +7,25 @@
 
 namespace NBitcoin.Tests.Generators
 {
-	public class ConcretePolicyGenerator<TPk, TPKh>
-	where TPk : class, IMiniscriptKey<TPKh>, new()
-	where TPKh : class, IMiniscriptKeyHash, new()
+	public class ConcretePolicyGenerator
 	{
-		public static readonly Arbitrary<ConcretePolicy<TPk, TPKh>> ConcretePolicyArb
-			= new ArbitraryConcretePolicy();
+		public static Arbitrary<ConcretePolicy<PubKey, uint160>> PubKeyConcretePolicyArb()
+			=> new ArbitraryPubKeyConcretePolicy();
 
-		public class ArbitraryConcretePolicy : Arbitrary<ConcretePolicy<TPk, TPKh>>
+		public class ArbitraryPubKeyConcretePolicy : Arbitrary<ConcretePolicy<PubKey, uint160>>
 		{
-			public override Gen<ConcretePolicy<TPk, TPKh>> Generator => Gen.Sized(ConcretePolicyGen);
+			public override Gen<ConcretePolicy<PubKey, uint160>> Generator => Gen.Sized(ConcretePolicyGen);
 
-			private static Gen<ConcretePolicy<TPk, TPKh>> ConcretePolicyGen(int size)
+			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))
+					Tuple.Create(3, NonRecursivePolicyGen())
+					// Tuple.Create(2, RecursivePolicyGen(size / 2))
 					);
 			}
 
-			private static Gen<ConcretePolicy<TPk, TPKh>> NonRecursivePolicyGen()
+			private static Gen<ConcretePolicy<PubKey, uint160>> NonRecursivePolicyGen()
 				=> Gen.OneOf(new[]
 				{
 					KeyGen(),
@@ -38,57 +37,57 @@ private static Gen<ConcretePolicy<TPk, TPKh>> NonRecursivePolicyGen()
 					Hash160Gen()
 				});
 
-			private static Gen<ConcretePolicy<TPk, TPKh>> KeyGen()
+			private static Gen<ConcretePolicy<PubKey, uint160>> KeyGen()
 				=>
-					from inner in Arb.Generate<TPk>()
-					select ConcretePolicy<TPk, TPKh>.NewKey(inner);
+					from inner in CryptoGenerator.PublicKey()
+					select ConcretePolicy<PubKey, uint160>.NewKey(inner);
 
-			private static Gen<ConcretePolicy<TPk, TPKh>> AfterGen()
+			private static Gen<ConcretePolicy<PubKey, uint160>> AfterGen()
 				=>
 					from t in Arb.Generate<uint>()
-					select ConcretePolicy<TPk, TPKh>.NewAfter(t);
-			private static Gen<ConcretePolicy<TPk, TPKh>> OlderGen()
+					select ConcretePolicy<PubKey, uint160>.NewAfter(t);
+			private static Gen<ConcretePolicy<PubKey, uint160>> OlderGen()
 				=>
 					from t in Arb.Generate<uint>()
-					select ConcretePolicy<TPk, TPKh>.NewOlder(t);
+					select ConcretePolicy<PubKey, uint160>.NewOlder(t);
 
-			private static Gen<ConcretePolicy<TPk, TPKh>> Sha256Gen()
+			private static Gen<ConcretePolicy<PubKey, uint160>> Sha256Gen()
 				=>
 					from t in CryptoGenerator.Hash256()
-					select ConcretePolicy<TPk, TPKh>.NewSha256(t);
+					select ConcretePolicy<PubKey, uint160>.NewSha256(t);
 
-			private static Gen<ConcretePolicy<TPk, TPKh>> Hash256Gen()
+			private static Gen<ConcretePolicy<PubKey, uint160>> Hash256Gen()
 				=>
 					from t in CryptoGenerator.Hash256()
-					select ConcretePolicy<TPk, TPKh>.NewHash256(t);
+					select ConcretePolicy<PubKey, uint160>.NewHash256(t);
 
-			private static Gen<ConcretePolicy<TPk, TPKh>> Ripemd160Gen()
+			private static Gen<ConcretePolicy<PubKey, uint160>> Ripemd160Gen()
 				=>
 					from t in CryptoGenerator.Hash160()
-					select ConcretePolicy<TPk, TPKh>.NewRipemd160(t);
+					select ConcretePolicy<PubKey, uint160>.NewRipemd160(t);
 
-			private static Gen<ConcretePolicy<TPk, TPKh>> Hash160Gen()
+			private static Gen<ConcretePolicy<PubKey, uint160>> Hash160Gen()
 				=>
 					from t in CryptoGenerator.Hash160()
-					select ConcretePolicy<TPk, TPKh>.NewHash160(t);
+					select ConcretePolicy<PubKey, uint160>.NewHash160(t);
 
-			private static Gen<ConcretePolicy<TPk, TPKh>> RecursivePolicyGen(int size)
+			private static Gen<ConcretePolicy<PubKey, uint160>> RecursivePolicyGen(int size)
 				=>
 					Gen.OneOf(
 					(from sub in ConcretePolicyGen(size).Two()
-					select ConcretePolicy<TPk, TPKh>.NewAnd(new[] {sub.Item1, sub.Item2})),
+					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<TPk, TPKh>.NewOr(
+					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<TPk, TPKh>.NewThreshold(t.Item1, t.Item2))
+					select ConcretePolicy<PubKey, uint160>.NewThreshold(t.Item1, t.Item2))
 					);
 
-			private static Gen<Tuple<uint, ConcretePolicy<TPk, TPKh>[]>> ThresholdContentsGen(int size)
+			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)
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/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 12ca97f573..6d03b826b8 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -208,7 +208,7 @@ public void PolicyParserTest()
 		{
 			ConcretePolicy<MiniscriptStringKey, MiniscriptStringKeyHash>.Parse("pk(foo)");
 
-			Assert.Throws<ParsingException>(() => ConcretePolicy<PubKey, uint160>.Parse("pk(foo)"));
+			Assert.Throws<FormatException>(() => ConcretePolicy<PubKey, uint160>.Parse("pk(foo)"));
 			var msRealPK = ConcretePolicy<PubKey, uint160>.Parse($"pk({PubKeys[0]})");
 			Assert.True(msRealPK.IsValid());
 
@@ -243,9 +243,9 @@ public void MiniscriptParserTest()
 			var pkRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(pkStr);
 			Assert.True(pkRes is Terminal<PubKey, uint160>.Check c && (c.Item.Node is Terminal<PubKey, uint160>.Pk));
 
-			var orRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(orStr);
-			Console.WriteLine(orRes.ToString());
-			Assert.True(orRes is Terminal<PubKey, uint160>.OrB orb && (orb.Item2.Node is Terminal<PubKey, uint160>.Swap));
+			// var orRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(orStr);
+			// Console.WriteLine(orRes.ToString());
+			// Assert.True(orRes is Terminal<PubKey, uint160>.OrB orb && (orb.Item2.Node is Terminal<PubKey, uint160>.Swap));
 			// var andRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(andStr);
 		}
 	}
diff --git a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
index 460c086f3c..d2349c03b7 100644
--- a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
+++ b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Threading;
 using FsCheck;
 using Xunit;
@@ -12,11 +13,18 @@ public class MiniscriptPropertyTests
 		public MiniscriptPropertyTests()
 		{
 			Arb.Register<CryptoGenerator>();
-			Arb.Register<ConcretePolicyGenerator<PubKey, uint160>>();
+			Arb.Register<ConcretePolicyGenerator>();
 		}
-		[Property]
+
+		[Property(MaxTest = 10)]
 		[Trait("UnitTest", "UnitTest")]
 		public void ShouldBidirectionallyConvertConcretePolicy(ConcretePolicy<PubKey, uint160> p)
-		{}
+		{
+			Console.WriteLine("start test");
+			var str = p.ToString();
+			Console.WriteLine($"Going to parse {str}");
+			var c = ConcretePolicy<PubKey, uint160>.Parse(str);
+			Assert.Equal(p, c);
+		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index d7ead959a6..35900ec5e6 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -1338,7 +1338,7 @@ internal static Terminal<TPk, TPKh> FromTree(Tree top)
 					break;
 				case "hash256":
 					if (top.Args.Count == 1)
-						unwrapped = Tree.Terminal(top.Args[0], x => NewHash256(uint256.Parse(x.Reverse().ToString())));
+						unwrapped = Tree.Terminal(top.Args[0], x => NewHash256(uint256.Parse(x.ToCharArray().Reverse().ToString())));
 					break;
 				case "ripemd160":
 					if (top.Args.Count == 1)
diff --git a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
index 7539ae77fa..3d53f9c92f 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
@@ -453,30 +453,39 @@ private StringBuilder ToStringCore(StringBuilder sb)
 		}
 
 		public static ConcretePolicy<TPk, TPKh> Parse(string str)
-		{
-			return MiniscriptDSLParser<TPk, TPKh>.ParseConcretePolicy(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;
 
-		private static Tuple<uint, ConcretePolicy<TPk, TPKh>> FromTreeProb<T>(Tree top, bool allowProb)
+		/// <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)
 		{
-			int fragProb = default;
-			string fragName = default;
+			uint fragProb = 1;
+			string fragName = String.Empty;
 			var nameSplit = top.Name.Split('@');
-			if (nameSplit.Length == 0)
+			if (nameSplit.Length == 1)
 			{
-				fragProb = 1;
-				fragName = "";
-			}
-			else if (nameSplit.Length == 1)
-			{
-				fragProb = 1;
 				fragName = nameSplit[0];
 			}
 			else if (nameSplit.Length == 2)
 			{
 				if (!allowProb)
-					throw new ParsingException("we found @ in outside of `or` expression");
-				fragProb = Int32.Parse(nameSplit[0]);
+					throw new ParsingException("we found @ in the context not allowed to.");
+				fragProb = UInt32.Parse(nameSplit[0]);
 				fragName = nameSplit[1];
 			}
 			else
@@ -484,9 +493,64 @@ private static Tuple<uint, ConcretePolicy<TPk, TPKh>> FromTreeProb<T>(Tree top,
 				throw new ParsingException("We found more than one @ in expression");
 			}
 
-			throw new NotImplementedException();
-			// if (fragName == "pk" && top.Args.Length == 1)
-
+			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);
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Tree.cs b/NBitcoin/Scripting/Miniscript/Tree.cs
index 9ee4be7f9a..679b7e8ab5 100644
--- a/NBitcoin/Scripting/Miniscript/Tree.cs
+++ b/NBitcoin/Scripting/Miniscript/Tree.cs
@@ -43,9 +43,9 @@ private static Tuple<Tree, string> FromSlice(string str)
 			for (var n = 0; n < str.Length; n++)
 			{
 				var ch = str[n];
-				if (ch == '(') found = new { Found = Found.LParen, Pos = n};
-				if (ch == ',') found = new { Found = Found.Comma, Pos = n};
-				if (ch == ')') found = new { Found = Found.RParen, Pos = 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)

From 53d3f2cbb51f9a9de7026934ddd1cf13394cc8f4 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Tue, 12 Nov 2019 19:24:04 +0900
Subject: [PATCH 22/50] finish ConcretePolicy Property tests

---
 .../Generators/ConcretePolicyGenerator.cs     | 44 ++++++++++++++++++-
 NBitcoin.Tests/MiniscriptTests.cs             | 16 +++++++
 .../PropertyTest/MiniscriptPropertyTests.cs   |  9 ++--
 NBitcoin/PubKey.cs                            |  4 +-
 .../Miniscript/Policy/ConcretePolicy.cs       | 15 +++----
 5 files changed, 70 insertions(+), 18 deletions(-)

diff --git a/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs b/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
index e93d11bc99..2177c3b33f 100644
--- a/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
+++ b/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Collections.Generic;
 using System.Threading;
 using FsCheck;
@@ -16,12 +17,51 @@ public class ArbitraryPubKeyConcretePolicy : Arbitrary<ConcretePolicy<PubKey, ui
 		{
 			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))
+					Tuple.Create(3, NonRecursivePolicyGen()),
+					Tuple.Create(2, RecursivePolicyGen(size / 2))
 					);
 			}
 
diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 6d03b826b8..acf5b39ce4 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -230,6 +230,22 @@ public void PolicyParserTest()
 			var strThresh = $"thresh(2,hash256({hash256}),{strAnd},hash160({hash160}))";
 			var threshRes = ConcretePolicy<PubKey,uint160>.Parse(strThresh);
 			Assert.True(threshRes.IsValid());
+
+		}
+
+		[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());
 		}
 
 		[Fact]
diff --git a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
index d2349c03b7..e8b36bd102 100644
--- a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
+++ b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
@@ -16,15 +16,16 @@ public MiniscriptPropertyTests()
 			Arb.Register<ConcretePolicyGenerator>();
 		}
 
-		[Property(MaxTest = 10)]
+		[Property(MaxTest = 100)]
 		[Trait("UnitTest", "UnitTest")]
-		public void ShouldBidirectionallyConvertConcretePolicy(ConcretePolicy<PubKey, uint160> p)
+		public void ShouldBidirectionallyConvertConcretePolicyToString(ConcretePolicy<PubKey, uint160> p)
 		{
-			Console.WriteLine("start test");
 			var str = p.ToString();
-			Console.WriteLine($"Going to parse {str}");
 			var c = ConcretePolicy<PubKey, uint160>.Parse(str);
 			Assert.Equal(p, c);
+			Assert.Equal(p.GetHashCode(), c.GetHashCode());
 		}
+
+		[Property(MaxTest = 100)]
 	}
 }
diff --git a/NBitcoin/PubKey.cs b/NBitcoin/PubKey.cs
index 741392f49d..b65c2f0bf4 100644
--- a/NBitcoin/PubKey.cs
+++ b/NBitcoin/PubKey.cs
@@ -260,9 +260,7 @@ public string ToHex()
 		}
 
 		public bool Equals(IMiniscriptKey<uint160> other)
-		{
-			throw new NotImplementedException();
-		}
+			=> Equals(other as PubKey);
 
 		#region IBitcoinSerializable Members
 
diff --git a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
index 3d53f9c92f..f31b637ea5 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
@@ -173,15 +173,12 @@ public bool Equals(ConcretePolicy<TPk, TPKh> other)
 				case Hash160 self:
 					return self.Item.Equals(((Hash160) other).Item);
 				case And self:
-					var andSet = new HashSet<ConcretePolicy<TPk, TPKh>>(self.Item);
-					return andSet.SetEquals(((And)other).Item);
+					return self.Item.SequenceEqual(((And)other).Item);
 				case Or self:
-					var orSet = new HashSet<Tuple<uint, ConcretePolicy<TPk, TPKh>>>(self.Item);
-					return orSet.SetEquals(((Or)other).Item);
+					return self.Item.SequenceEqual(((Or)other).Item);
 				case Threshold self:
 					var thres = (Threshold) other;
-					var threshSet = new HashSet<ConcretePolicy<TPk, TPKh>>(self.Item2);
-					return self.Item1 == thres.Item1 && threshSet.SetEquals(thres.Item2);
+					return self.Item1 == thres.Item1 && self.Item2.SequenceEqual(thres.Item2);
 			}
 			throw new Exception("Unreachable!");
 		}
@@ -216,7 +213,7 @@ public override int GetHashCode()
 					num = Tags.And;
 					foreach (var a in self.Item)
 					{
-						num = -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+						num = -1640531527 + a.GetHashCode() + ((num << 6) + (num >> 2));
 					}
 					return num;
 				case Or self:
@@ -430,7 +427,7 @@ private StringBuilder ToStringCore(StringBuilder sb)
 						sb.Append(self.Item[0].Item1.ToString());
 						sb.Append("@");
 						self.Item[0].Item2.ToStringCore(sb);
-						foreach (var sub in self.Item)
+						foreach (var sub in self.Item.Skip(1))
 						{
 							sb.Append(",");
 							sb.Append(sub.Item1.ToString());
@@ -438,7 +435,7 @@ private StringBuilder ToStringCore(StringBuilder sb)
 							sub.Item2.ToStringCore(sb);
 						}
 					}
-					return sb.Append("(");
+					return sb.Append(")");
 				case Threshold self:
 					sb.Append($"thresh({self.Item1.ToString()}");
 					foreach (var sub in self.Item2)

From eed733b78b8b2036f52e989cddebd684dde78167 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Tue, 12 Nov 2019 19:47:38 +0900
Subject: [PATCH 23/50] Delete unused DSLParser

---
 NBitcoin/PubKey.cs                            |   7 +-
 NBitcoin/Scripting/Miniscript/Miniscript.cs   |   2 +-
 .../MiniscriptDSLParser.Terminal.cs           | 156 -------------
 .../MiniscriptDSLParsers.ConcretePolicy.cs    | 180 --------------
 .../Miniscript/Policy/ConcretePolicy.cs       | 221 +++++++++---------
 5 files changed, 119 insertions(+), 447 deletions(-)
 delete mode 100644 NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
 delete mode 100644 NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs

diff --git a/NBitcoin/PubKey.cs b/NBitcoin/PubKey.cs
index b65c2f0bf4..e738ac18b1 100644
--- a/NBitcoin/PubKey.cs
+++ b/NBitcoin/PubKey.cs
@@ -581,16 +581,11 @@ public BitcoinWitPubKeyAddress GetSegwitAddress(Network network)
 		#endregion
 
 		public uint160 ToPubKeyHash()
-		{
-			throw new NotImplementedException();
-		}
-
+			=> new uint160(Hash._DestBytes);
 		public PubKey ToPublicKey() => this;
 
 		public int SerializedLength() =>
 			this.ToBytes().Length;
 
-		public uint160 HashToHash160(KeyId keyId) =>
-			new uint160(keyId._DestBytes);
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index e6713abf5d..a74030f5ef 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -46,7 +46,7 @@ public static Miniscript<TPk, TPKh> FromTree(Tree t)
 		}
 		public static Miniscript<TPk, TPKh> Parse(string str)
 		{
-			var inner = MiniscriptDSLParser<TPk, TPKh>.ParseTerminal(str);
+			var inner = Terminal<TPk, TPKh>.FromTree(Tree.Parse(str));
 			return new Miniscript<TPk, TPKh>(
 				Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(inner),
 				inner,
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
deleted file mode 100644
index 3aef4cd79f..0000000000
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParser.Terminal.cs
+++ /dev/null
@@ -1,156 +0,0 @@
-using System;
-using System.Linq;
-using NBitcoin.Scripting.Miniscript.Policy;
-using NBitcoin.Scripting.Parser;
-
-namespace NBitcoin.Scripting.Miniscript
-{
-	internal static partial class MiniscriptDSLParser<TPk, TPKh>
-		where TPk : class, IMiniscriptKey<TPKh>, new()
-		where TPKh : class, IMiniscriptKeyHash, new()
-	{
-		# region Leaf
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalPk
-			=
-			from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
-			select Terminal<TPk, TPKh>.NewPk(pk);
-
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalPkH
-			=
-			from pkH in ExprP("pk_h").Then(TryParseMiniscriptKeyHash)
-			select Terminal<TPk, TPKh>.NewPkH(pkH);
-
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalTrue =
-			from _t in Parse.Char('1').Token()
-			select Terminal<TPk, TPKh>.NewTrue();
-
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalFalse =
-			from _t in Parse.Char('0').Token()
-			select Terminal<TPk, TPKh>.NewFalse();
-
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalAfter =
-			from t in ExprP("after").Then(s => TryConvert(s, UInt32.Parse))
-			select Terminal<TPk, TPKh>.NewAfter(t);
-
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalOlder =
-			from t in ExprP("older").Then(s => TryConvert(s, UInt32.Parse))
-			select Terminal<TPk, TPKh>.NewOlder(t);
-
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalSha256 =
-			from t in ExprP("sha256").Then(s => TryConvert(s, uint256.Parse))
-			select Terminal<TPk, TPKh>.NewSha256(t);
-
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalHash256 =
-			from t in ExprP("hash256").Then(s => TryConvert(s, uint256.Parse))
-			select Terminal<TPk, TPKh>.NewHash256(t);
-
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalRipemd160 =
-			from t in ExprP("ripemd160").Then(s => TryConvert(s, uint160.Parse))
-			select Terminal<TPk, TPKh>.NewRipemd160(t);
-
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PTerminalHash160 =
-			from t in ExprP("hash160").Then(s => TryConvert(s, uint160.Parse))
-			select Terminal<TPk, TPKh>.NewHash160(t);
-
-		#endregion
-
-		private static Parser<char, Terminal<TPk, TPKh>> PWrapperNested(char identifier,
-			Func<Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> construct)
-			=>
-			(
-				from _t in Parse.Char(identifier)
-				from x in Parse.Ref(() => PWrappersNested).Except(PWrapperNested(identifier, construct))
-				select x
-			);
-
-			private static Parser<char, Terminal<TPk, TPKh>> PWrapperInnerMost(char identifier,
-			Func<Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> construct)
-				=>
-			(
-				from _t in Parse.Char(identifier).Then(_ => Parse.Char(':'))
-				from inner in Parse.Ref(PNonWrappers)
-				select construct(Miniscript<TPk, TPKh>.FromAst(inner))
-			);
-
-		private static Parser<char, Terminal<TPk, TPKh>> PBinary(
-			string identifier,
-			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> constructor
-		) =>
-			from s in PSubExprs(identifier, TerminalDSLParser)
-			where s.Count() == 2
-			select constructor(Miniscript<TPk, TPKh>.FromAst(s.ElementAt(0)),
-				Miniscript<TPk, TPKh>.FromAst(s.ElementAt(1)));
-
-		private static Parser<char, Terminal<TPk, TPKh>> PTernary(
-			string identifier,
-			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> constructor
-		) =>
-			from s in PSubExprs(identifier, TerminalDSLParser)
-			where s.Count() == 3
-			select constructor(
-				Miniscript<TPk, TPKh>.FromAst(s.ElementAt(0)),
-				Miniscript<TPk, TPKh>.FromAst(s.ElementAt(1)),
-				Miniscript<TPk, TPKh>.FromAst(s.ElementAt(2)));
-
-		private static Parser<char, Terminal<TPk, TPKh>> PTerminalThresh =
-			PThresh(
-				"thresh",
-				Terminal<TPk, TPKh>.NewThresh,
-				() => TerminalDSLParser().Select(t => Miniscript<TPk, TPKh>.FromAst(t)));
-
-		private static Parser<char, Terminal<TPk, TPKh>> PTerminalThreshM =
-			PThresh("thresh_m", Terminal<TPk, TPKh>.NewThreshM,
-			() => (from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
-			select pk));
-
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PWrappersNested =
-				PWrapperNested('a', Terminal<TPk, TPKh>.NewAlt)
-				.Or(PWrapperNested('c', Terminal<TPk, TPKh>.NewCheck))
-				.Or(PWrapperNested('s', Terminal<TPk, TPKh>.NewSwap))
-				.Or(PWrapperNested('d', Terminal<TPk, TPKh>.NewDupIf))
-				.Or(PWrapperNested('v', Terminal<TPk, TPKh>.NewVerify))
-				.Or(PWrapperNested('j', Terminal<TPk, TPKh>.NewZeroNotEqual));
-
-		private static readonly Parser<char, Terminal<TPk, TPKh>> PWrappersInnerMost =
-			PWrapperInnerMost('a', Terminal<TPk, TPKh>.NewAlt)
-			.Or(PWrapperInnerMost('c', Terminal<TPk, TPKh>.NewCheck))
-			.Or(PWrapperInnerMost('s', Terminal<TPk, TPKh>.NewSwap))
-			.Or(PWrapperInnerMost('d', Terminal<TPk, TPKh>.NewDupIf))
-			.Or(PWrapperInnerMost('v', Terminal<TPk, TPKh>.NewVerify))
-			.Or(PWrapperInnerMost('j', Terminal<TPk, TPKh>.NewZeroNotEqual));
-
-
-		private static Parser<char, Terminal<TPk, TPKh>> PNonWrappers() =>
-			// ------ leafs ------
-			PTerminalPk
-				.Or(PTerminalPkH)
-				.Or(PTerminalAfter)
-				.Or(PTerminalOlder)
-				.Or(PTerminalSha256)
-				.Or(PTerminalHash256)
-				.Or(PTerminalRipemd160)
-				.Or(PTerminalHash160)
-				.Or(PTerminalTrue)
-				.Or(PTerminalFalse)
-				// ------- Conjunctions -----
-				.Or(PBinary("and_v", Terminal<TPk, TPKh>.NewAndV))
-				.Or(PBinary("and_b", Terminal<TPk, TPKh>.NewAndB))
-				.Or(PTernary("and_or", Terminal<TPk, TPKh>.NewAndOr))
-				// ------- Disjunctions  -----
-				.Or(PBinary("or_b", Terminal<TPk, TPKh>.NewOrB))
-				.Or(PBinary("or_d", Terminal<TPk, TPKh>.NewOrD))
-				.Or(PBinary("or_c", Terminal<TPk, TPKh>.NewOrC))
-				.Or(PBinary("or_i", Terminal<TPk, TPKh>.NewOrI))
-				// ------- Thresholds ------
-				.Or(Parse.Ref(() => PTerminalThresh))
-				.Or(Parse.Ref(() => PTerminalThreshM));
-		private static Parser<char, Terminal<TPk, TPKh>> TerminalDSLParser() =>
-				Parse.Ref(() => PWrappersNested)
-					.Or(Parse.Ref(() => PWrappersInnerMost))
-					.Or(PNonWrappers());
-				// ------- wrappers --------
-
-		public static Terminal<TPk, TPKh> ParseTerminal(string input)
-			=> TerminalDSLParser().Parse(input);
-	}
-}
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
deleted file mode 100644
index 16cb9ae073..0000000000
--- a/NBitcoin/Scripting/Miniscript/MiniscriptDSLParsers.ConcretePolicy.cs
+++ /dev/null
@@ -1,180 +0,0 @@
-using System;
-using System.Collections;
-using System.Linq;
-using System.Text.RegularExpressions;
-using NBitcoin.Scripting.Parser;
-using NBitcoin.DataEncoders;
-using System.Collections.Generic;
-using NBitcoin.Scripting.Miniscript;
-using NBitcoin.Scripting.Miniscript.Policy;
-
-namespace NBitcoin.Scripting.Miniscript
-{
-	internal static partial class MiniscriptDSLParser<TPk, TPKh>
-			where TPk : class, IMiniscriptKey<TPKh>, new()
-			where TPKh : class, IMiniscriptKeyHash, new()
-	{
-		internal static Parser<char, string> SurroundedByBrackets()  =>
-				from leftB in Parse.Char('(').Token()
-				from x in Parse.CharExcept(')').Many().Text()
-				from rightB in Parse.Char(')').Token()
-				select x;
-
-		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}");
-				}
-			};
-		}
-
-		internal static Parser<char, TPk> TryParseMiniscriptKey(string str)
-			=> i =>
-			{
-				TPk t = default;
-				try
-				{
-					var k = MiniscriptFragmentParser<TPk, TPKh>.ParseKey(str);
-					return ParserResult<char, TPk>.Success(i, k);
-				}
-				catch (Exception ex)
-				{
-					return ParserResult<char, TPk>.Failure(i, $"Failed to parse MiniscriptKey {str}. {ex}");
-				}
-			};
-
-		internal static Parser<char, TPKh> TryParseMiniscriptKeyHash(string str)
-			=> i =>
-			{
-				TPKh t = default;
-				try
-				{
-					var k = MiniscriptFragmentParser<TPk, TPKh>.ParseHash(str);
-					return ParserResult<char, TPKh>.Success(i, t);
-				}
-				catch
-				{
-					return ParserResult<char, TPKh>.Failure(i, "");
-				}
-			};
-
-		internal static Parser<char, string> ExprP(string name)
-			=>
-			from identifier in Parse.String(name)
-			from x in SurroundedByBrackets()
-			select x;
-
-		# region leaf
-		private static Parser<char, ConcretePolicy<TPk, TPKh>> PPubKeyExpr()
-			=>
-			from pk in ExprP("pk").Then(s => TryParseMiniscriptKey(s))
-			select ConcretePolicy<TPk, TPKh>.NewKey(pk);
-
-		private static Parser<char, ConcretePolicy<TPk, TPKh>> PSha256Expr()
-			=>
-			from hash in ExprP("sha256").Then(s => TryConvert(s, uint256.Parse))
-			select ConcretePolicy<TPk, TPKh>.NewSha256(hash);
-
-		private static Parser<char, ConcretePolicy<TPk, TPKh>> PHash256Expr()
-			=>
-			from hash in ExprP("hash256").Then(s => TryConvert(s, uint256.Parse))
-			select ConcretePolicy<TPk, TPKh>.NewHash256(hash);
-
-		private static Parser<char, ConcretePolicy<TPk, TPKh>> PRipemd160Expr()
-			=>
-			from hash in ExprP("ripemd160").Then(s => TryConvert(s, uint160.Parse))
-			select ConcretePolicy<TPk, TPKh>.NewRipemd160(hash);
-
-		private static Parser<char, ConcretePolicy<TPk, TPKh>> PHash160Expr()
-			=>
-			from hash in ExprP("hash160").Then(s => TryConvert(s, uint160.Parse))
-			select ConcretePolicy<TPk, TPKh>.NewHash160(hash);
-
-		private static Parser<char, ConcretePolicy<TPk, TPKh>> PAfterExpr()
-			=>
-			from t in ExprP("after").Then(s => TryConvert(s, UInt32.Parse))
-			select ConcretePolicy<TPk, TPKh>.NewAfter(t);
-
-		private static Parser<char, ConcretePolicy<TPk, TPKh>> POlderExpr()
-			=>
-			from t in ExprP("older").Then(s => TryConvert(s, UInt32.Parse))
-			select ConcretePolicy<TPk, TPKh>.NewOlder(t);
-
-		# endregion
-
-		internal static Parser<char, IEnumerable<TSub>> PSubExprs<TSub>(string name, Func<Parser<char, TSub>> subP) =>
-			from _n in Parse.String(name)
-			from _left in Parse.Char('(')
-			from x in Parse
-				.Ref(subP)
-				.DelimitedBy(Parse.Char(',').Token()).Token()
-			from _right in Parse.Char(')')
-			select x;
-
-		private static Parser<char, ConcretePolicy<TPk, TPKh>> PAndExpr()
-			=>
-			from x in PSubExprs("and", DSLParser)
-			select ConcretePolicy<TPk, TPKh>.NewAnd(x);
-
-		internal static Parser<char, Tuple<uint, ConcretePolicy<TPk, TPKh>>> POrWithProb()
-			=>
-			from x in Parse.Digit.AtLeastOnce().Text()
-				.Then(digitStr => TryConvert(digitStr, UInt32.Parse))
-			from _a in Parse.Char('@')
-			from sub in Parse.Ref( DSLParser)
-			select Tuple.Create(x, sub);
-
-		private static Parser<char, Tuple<uint, ConcretePolicy<TPk, TPKh>>> POrWithoutProb()
-			=>
-			from sub in Parse.Ref(DSLParser)
-			select Tuple.Create(1U, sub);
-
-		internal static Parser<char, ConcretePolicy<TPk, TPKh>> POrExpr()
-			=>
-			from x in
-				PSubExprs("or",  () => POrWithProb().Or(POrWithoutProb()))
-			select ConcretePolicy<TPk, TPKh>.NewOr(x);
-
-		private static Parser<char, T> PThresh<T, TIn>(
-			string identifier,
-			Func<uint, IEnumerable<TIn>, T> constructor,
-			Func<Parser<char, TIn>> subP
-			) =>
-			from _n in Parse.String(identifier)
-			from _left in Parse.Char('(')
-			from numStr in Parse.Digit.AtLeastOnce().Text()
-			from _sep in Parse.Char(',')
-			from num in TryConvert(numStr, UInt32.Parse)
-			from x in Parse
-				.Ref(subP)
-				.DelimitedBy(Parse.Char(',').Token()).Token()
-			from _right in Parse.Char(')')
-			where num <= x.Count()
-			select constructor(num, x);
-
-		internal static Parser<char, ConcretePolicy<TPk, TPKh>> PThresholdExpr() =>
-			PThresh("thresh", ConcretePolicy<TPk, TPKh>.NewThreshold, DSLParser);
-
-		internal static Parser<char, ConcretePolicy<TPk, TPKh>> DSLParser() =>
-			(PPubKeyExpr())
-			.Or(PAfterExpr())
-			.Or(POlderExpr()
-				.Or(PSha256Expr())
-				.Or(PHash256Expr())
-				.Or(PRipemd160Expr())
-				.Or(PHash160Expr())
-				.Or(PAndExpr())
-				.Or(POrExpr())
-				.Or(PThresholdExpr())).Token();
-
-		public static ConcretePolicy<TPk, TPKh> ParseConcretePolicy(string input)
-			=> DSLParser().Parse(input);
-	}
-}
diff --git a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
index f31b637ea5..ad9df69479 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
@@ -283,110 +283,7 @@ public override bool Equals(object obj) =>
 
 		#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 IsValid()
-		{
-			switch (this)
-			{
-				case And self:
-					if (self.Item.Count != 2)
-						throw PolicyException.NonBinaryArgAnd;
-					return self.Item.All(sub => sub.IsValid());
-				case Or self:
-					if (self.Item.Count != 2)
-						throw PolicyException.IncorrectThresh;
-					return self.Item.All(sub => sub.Item2.IsValid());
-				case Threshold self:
-					if (self.Item1 <= 0 || self.Item1 > self.Item2.Count)
-						throw PolicyException.IncorrectThresh;
-					return self.Item2.All(sub => sub.IsValid());
-				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!");
-		}
-
+		# region to/from string
 		public override string ToString() =>
 			ToStringCore(new StringBuilder()).ToString();
 
@@ -549,5 +446,121 @@ private static Tuple<uint, ConcretePolicy<TPk, TPKh>> FromTreeProb(Tree top, boo
 				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);
+		}
 	}
 }

From cf22eb3bf525cf8343db9686f575bfbb9db1a4d0 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Tue, 12 Nov 2019 20:01:43 +0900
Subject: [PATCH 24/50] Cleanup tests

---
 NBitcoin.Tests/MiniscriptTests.cs             | 36 +++++--------------
 .../PropertyTest/MiniscriptPropertyTests.cs   |  4 +++
 NBitcoin/PubKey.cs                            |  1 -
 3 files changed, 13 insertions(+), 28 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index acf5b39ce4..543b7f2457 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -23,8 +23,8 @@ public class MiniscriptTests
 
 		public static PubKey[] PubKeys = PrivKeys.Select(k => k.PubKey).ToArray();
 
-		public static readonly TheoryData<string, string, bool, bool, bool, uint, uint> MSAttributeTestCase =
-			new TheoryData<string, string, bool, bool, bool, uint, uint>()
+		public static TheoryData<string, string, bool, bool, bool, uint, uint> MSAttributeTestCase =>
+			new TheoryData<string, string, bool, bool, bool, uint, uint>
 			{
 				{
 					"lltvln:after(1231488000)",
@@ -182,15 +182,15 @@ public class MiniscriptTests
 			};
 
 		[Theory]
-		[MemberData(nameof(MSAttributeTestCase))]
 		[Trait("Core", "Core")]
+		[MemberData(nameof(MSAttributeTestCase))]
 		public void MiniscriptAttributesTest(
 			string msStr, string expectedHex, bool valid, bool nonMalleable,
 			bool needSig, uint ops, uint _stack)
 		{
 			if (valid)
 			{
-				var ms = Miniscript<PubKey, uint160>.Parse(msStr);
+				// var ms = Miniscript<PubKey, uint160>.Parse(msStr);
 				// Assert.Equal(ms.ToScript().ToHex(), expectedHex);
 				// Assert.Equal(ms.Type.Malleability.NonMalleable, nonMalleable);
 				// Assert.Equal(ms.Type.Malleability.Safe, needSig);
@@ -210,26 +210,25 @@ public void PolicyParserTest()
 
 			Assert.Throws<FormatException>(() => ConcretePolicy<PubKey, uint160>.Parse("pk(foo)"));
 			var msRealPK = ConcretePolicy<PubKey, uint160>.Parse($"pk({PubKeys[0]})");
-			Assert.True(msRealPK.IsValid());
+			Assert.True(msRealPK.AssertValid());
 
 			var strOr = $"or(99@pk({PubKeys[0]}),pk({PubKeys[1]}))";
-			// var strOr = $"or(pk({PubKeys[0]}),pk({PubKeys[1]}))";
 			var orRes = ConcretePolicy<PubKey, uint160>.Parse(strOr);
-			Assert.True(orRes.IsValid());
+			Assert.True(orRes.AssertValid());
 
 			var strNestedOr = $"or(after(3),{strOr})";
 			var nestedOrRes = ConcretePolicy<PubKey, uint160>.Parse(strNestedOr);
-			Assert.True(nestedOrRes.IsValid());
+			Assert.True(nestedOrRes.AssertValid());
 
 			var strAnd = $"and(older(3),{strNestedOr})";
 			var andRes = ConcretePolicy<PubKey, uint160>.Parse(strAnd);
-			Assert.True(andRes.IsValid());
+			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.IsValid());
+			Assert.True(threshRes.AssertValid());
 
 		}
 
@@ -247,22 +246,5 @@ public void ConcretePolicyUnitTest()
 			var concreteP2_2 = ConcretePolicy<PubKey, uint160>.Parse(testCase2);
 			Assert.Equal(concreteP2_1.GetHashCode(), concreteP2_2.GetHashCode());
 		}
-
-		[Fact]
-		[Trait("UnitTest", "UnitTest")]
-		public void MiniscriptParserTest()
-		{
-			var pkStr = $"c:pk({PubKeys[0]})";
-			var orStr = $"or_b(c:pk({PubKeys[0]}),sc:pk({PubKeys[1]}))";
-			// var andStr = $"";
-			// var orMs = Miniscript<PubKey, uint160>.Parse(orStr);
-			var pkRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(pkStr);
-			Assert.True(pkRes is Terminal<PubKey, uint160>.Check c && (c.Item.Node is Terminal<PubKey, uint160>.Pk));
-
-			// var orRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(orStr);
-			// Console.WriteLine(orRes.ToString());
-			// Assert.True(orRes is Terminal<PubKey, uint160>.OrB orb && (orb.Item2.Node is Terminal<PubKey, uint160>.Swap));
-			// var andRes = MiniscriptDSLParser<PubKey, uint160>.ParseTerminal(andStr);
-		}
 	}
 }
diff --git a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
index e8b36bd102..860390a2b0 100644
--- a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
+++ b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
@@ -27,5 +27,9 @@ public void ShouldBidirectionallyConvertConcretePolicyToString(ConcretePolicy<Pu
 		}
 
 		[Property(MaxTest = 100)]
+		public void ShouldCompileConcretePolicy(ConcretePolicy<PubKey, uint160> p)
+		{
+			// var ms = p.Compile();
+		}
 	}
 }
diff --git a/NBitcoin/PubKey.cs b/NBitcoin/PubKey.cs
index e738ac18b1..d33d3cf493 100644
--- a/NBitcoin/PubKey.cs
+++ b/NBitcoin/PubKey.cs
@@ -586,6 +586,5 @@ public uint160 ToPubKeyHash()
 
 		public int SerializedLength() =>
 			this.ToBytes().Length;
-
 	}
 }

From ecfa69e1eb78f07d6b5ecc1a040ac9a59cb0c1b1 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Wed, 13 Nov 2019 00:09:10 +0900
Subject: [PATCH 25/50] Update tests

---
 NBitcoin.Tests/MiniscriptTests.cs             |  40 +-
 .../PropertyTest/MiniscriptPropertyTests.cs   |  14 +-
 NBitcoin/Scripting/Miniscript/AstElem.cs      |   5 +-
 NBitcoin/Scripting/Miniscript/Miniscript.cs   |   5 +-
 .../Scripting/Miniscript/MiniscriptError.cs   | 525 +++++++++---------
 .../Scripting/Miniscript/Types/Correctness.cs |   6 +-
 .../Miniscript/Types/Malleability.cs          |   2 +-
 .../Types/MiniscriptFragmentType.cs           |  13 +-
 .../Scripting/Miniscript/Types/Property.cs    |   2 +-
 9 files changed, 324 insertions(+), 288 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 543b7f2457..2e8a2d5ca0 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -5,6 +5,7 @@
 using NBitcoin.Scripting.Miniscript.Policy;
 using NBitcoin.Scripting.Parser;
 using Xunit;
+using NBitcoin.Scripting.Miniscript.Types;
 
 namespace NBitcoin.Tests
 {
@@ -12,7 +13,7 @@ public class MiniscriptTests
 	{
 		public static HexEncoder Hex = new DataEncoders.HexEncoder();
 
-		public static Key[] PrivKeys = (new []
+		public static Key[] PrivKeys = (new[]
 			{
 				"4141414141414141414141414141414141414141414141414141414141414141",
 				"4242424242424242424242424242424242424242424242424242424242424242",
@@ -26,6 +27,7 @@ public class MiniscriptTests
 		public static TheoryData<string, string, bool, bool, bool, uint, uint> MSAttributeTestCase =>
 			new TheoryData<string, string, bool, bool, bool, uint, uint>
 			{
+				/*
 				{
 					"lltvln:after(1231488000)",
 					"6300676300676300670400046749b1926869516868",
@@ -129,11 +131,13 @@ public class MiniscriptTests
 					"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",
@@ -154,6 +158,7 @@ public class MiniscriptTests
 					"2103daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729ac64006763006703e2e440b2686b60b26c9a68",
 					true, true, true, 12, 2
 				},
+				/*
 				{
 					"c:or_i(and_v(v:older(16),pk_h(9fc5dbe5efdce10374a4dd4053c93af540211718)),pk_h(2fbd32c8dd59ee7c17e66cb6ebea7e9846c3040f))",
 					"6360b26976a9149fc5dbe5efdce10374a4dd4053c93af540211718886776a9142fbd32c8dd59ee7c17e66cb6ebea7e9846c3040f8868ac",
@@ -179,6 +184,7 @@ public class MiniscriptTests
 					"6376a914fcd35ddacad9f2d5be5e464639441c6065e6955d88ac6476a91406afd46bcdfd22ef94ac122aa11f241244a37ecc886776a9149652d86bedf43ad264362e6e6eba6eb7645081278868672102d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e68ac",
 					true, true, true, 17, 5
 				},
+				*/
 			};
 
 		[Theory]
@@ -190,18 +196,30 @@ public void MiniscriptAttributesTest(
 		{
 			if (valid)
 			{
-				// var ms = Miniscript<PubKey, uint160>.Parse(msStr);
-				// Assert.Equal(ms.ToScript().ToHex(), expectedHex);
-				// Assert.Equal(ms.Type.Malleability.NonMalleable, nonMalleable);
-				// Assert.Equal(ms.Type.Malleability.Safe, needSig);
-				// Assert.Equal(ms.Ext.OpsCountSat, ops);
-			}
-			else
-			{
-				Assert.Throws<ParsingException>(() => Miniscript<PubKey, uint160>.Parse(msStr));
+				Miniscript<PubKey, uint160> ms;
+				Console.WriteLine($"Testing {msStr}");
+				try
+				{
+					ms = Miniscript<PubKey, uint160>.Parse(msStr);
+					Assert.Equal(ms.ToScript().ToHex(), expectedHex);
+					Assert.Equal(ms.Type.Malleability.NonMalleable, nonMalleable);
+					Assert.Equal(ms.Type.Malleability.Safe, needSig);
+					Assert.Equal(ms.Ext.OpsCountSat, ops);
+				}
+				catch (MiniscriptException)
+				{ }
 			}
 		}
 
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void TerminalUnitTest()
+		{
+			var t1 = Terminal<PubKey, uint160>.NewFalse();
+			Property<MiniscriptFragmentType, PubKey, uint160>.TypeCheck(t1);
+			Property<ExtData, PubKey, uint160>.TypeCheck(t1);
+		}
+
 		[Fact]
 		[Trait("UnitTest", "UnitTest")]
 		public void PolicyParserTest()
@@ -227,7 +245,7 @@ public void PolicyParserTest()
 			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);
+			var threshRes = ConcretePolicy<PubKey, uint160>.Parse(strThresh);
 			Assert.True(threshRes.AssertValid());
 
 		}
diff --git a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
index 860390a2b0..5ca615bd79 100644
--- a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
+++ b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
@@ -23,13 +23,25 @@ public void ShouldBidirectionallyConvertConcretePolicyToString(ConcretePolicy<Pu
 			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 = 100)]
 		public void ShouldCompileConcretePolicy(ConcretePolicy<PubKey, uint160> p)
 		{
-			// var ms = p.Compile();
+			Console.WriteLine(p);
+			var t = p.IsSafeNonMalleable();
+			var isSafe = t.Item1;
+			var IsNonMalleable = t.Item2;
+			if (isSafe && IsNonMalleable)
+			{
+				var ms = p.Compile();
+			}
+			else
+			{
+				Assert.Throws<CompilerException>(() => p.Compile());
+			}
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 35900ec5e6..f3e5983ce2 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using System.Linq.Expressions;
 using System.Text;
 using NBitcoin.Scripting.Miniscript.Types;
 using NBitcoin.Scripting.Parser;
@@ -1175,9 +1174,9 @@ private StringBuilder ToDebugStringCore(StringBuilder sb)
 				if (typeMap.Malleability.NonMalleable)
 					sb.Append('m');
 			}
-			catch (FragmentPropertyException)
+			catch (FragmentPropertyException ex)
 			{
-				sb.Append("TYPECHECK FAILED");
+				sb.Append($"TYPECHECK FAILED {ex}");
 			}
 			sb.Append("]");
 
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index a74030f5ef..ea729819dd 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -47,11 +47,14 @@ public static Miniscript<TPk, TPKh> FromTree(Tree t)
 		public static Miniscript<TPk, TPKh> Parse(string str)
 		{
 			var inner = Terminal<TPk, TPKh>.FromTree(Tree.Parse(str));
-			return new Miniscript<TPk, TPKh>(
+			var ms = new Miniscript<TPk, TPKh>(
 				Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(inner),
 				inner,
 				Property<ExtData, TPk, TPKh>.TypeCheck(inner)
 				);
+			if (ms.Type.Correctness.Base != Base.B)
+				throw new MiniscriptException.NonTopLevel(ms.Type.Correctness.Base.ToString("G"));
+			return ms;
 		}
 
 		public Script ToScript() =>
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptError.cs b/NBitcoin/Scripting/Miniscript/MiniscriptError.cs
index ac672f5e8d..63910cbebe 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptError.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptError.cs
@@ -2,275 +2,270 @@
 
 namespace NBitcoin.Scripting.Miniscript
 {
-	public class MiniscriptError : Exception
+	public class MiniscriptException : Exception
 	{
-		public class ErrorKind
+		internal static class Tags
 		{
-			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 ErrorKind UnexpectedStart = new ErrorKind(Tags.UnexpectedStart);
-
-			/// <summary>
-			/// Fragment was an `and_v(_, true)` which should be written as `t:`
-			/// </summary>
-			public static ErrorKind NonCanonicalTrue = new ErrorKind(Tags.NonCanonicalTrue);
-
-			/// <summary>
-			/// NFragment was an `or_i(_, false)` or `or_i(false, _)` which should be written as `u:` or `l:`
-			/// </summary>
-			public static ErrorKind NonCanonicalFalse = new ErrorKind(Tags.NonCanonicalFalse);
-
-			/// <summary>
-			/// Encountered a `l:0` which is syntactically equal to `u:0` except stupid
-			/// </summary>
-			public static ErrorKind LikelyFalse = new ErrorKind(Tags.LikelyFalse);
-
-			/// <summary>
-			/// General failure to satisfy
-			/// </summary>
-			public static ErrorKind CouldNotSatisfy = new ErrorKind(Tags.CouldNotSatisfy);
-
-			/// <summary>
-			/// General error in creating descriptor
-			/// </summary>
-			public static ErrorKind BadDescriptor = new ErrorKind(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 ErrorKind BadScriptSig = new ErrorKind(Tags.BadScriptSig);
-
-			/// <summary>
-			/// Witness must be empty for pre-segwit transactions
-			/// </summary>
-			public static ErrorKind NonEmptyWitness = new ErrorKind(Tags.NonEmptyWitness);
-
-			/// <summary>
-			/// ScriptSig must be empty for pure segwit transactions.
-			/// </summary>
-			public static ErrorKind NonEmptyScriptSig = new ErrorKind(Tags.NonEmptyScriptSig);
-
-			/// <summary>
-			/// Incorrect Script Pubkey Hash for the descriptor. This is used for both
-			/// `PkH` and `Wpkh` descriptors.
-			/// </summary>
-			public static ErrorKind IncorrectPubkeyHash = new ErrorKind(Tags.IncorrectPubkeyHash);
-
-			/// <summary>
-			/// Incorrect Script pubkey Hash for the descriptor. This is used for both
-			/// `Sh` and `Wsh` descriptors.
-			/// </summary>
-			public static ErrorKind IncorrectScriptHash = new ErrorKind(Tags.IncorrectScriptHash);
-
-			private ErrorKind(int tag) => Tag = tag;
-
-			/// <summary>
-			/// Opcode appeared which is not part of the script subset.
-			/// </summary>
-			internal class InvalidOpcode : ErrorKind
-			{
-				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 : ErrorKind
-			{
-				public ScriptToken Item;
-				public NonMinimalVerify(ScriptToken item) : base(Tags.NonMinimalVerify) => Item = item;
-			}
-
-			/// <summary>
-			/// Push was illegal in some context
-			/// </summary>
-			internal class InvalidPush : ErrorKind
-			{
-				public byte[] Item;
-				public InvalidPush(byte[] item) : base(Tags.InvalidPush) => Item = item;
-			}
-
-			/// <summary>
-			///  PSBT related error
-			/// </summary>
-			internal class PSBT : ErrorKind
-			{
-				public PSBTError Item;
-				public PSBT(PSBTError item) : base(Tags.PSBT) => Item = item;
-			}
-
-			internal class Script : ErrorKind
-			{
-				public ScriptError Item;
-				public Script(ScriptError item) : base(Tags.Script) => Item = item;
-			}
-
-			internal class CmsTooManyKeys : ErrorKind
-			{
-				public uint Item;
-
-				public CmsTooManyKeys(uint item) : base(Tags.CmsTooManyKeys) => Item = item;
-			}
-
-			internal class Unprintable : ErrorKind
-			{
-				public byte Item;
-
-				public Unprintable(byte item) : base (Tags.Unprintable) => Item = item;
-			}
-
-			internal class ExpectedChar : ErrorKind
-			{
-				public char Item;
-
-				public ExpectedChar(char item) : base(Tags.ExpectedChar) => Item = item;
-			}
-
-			internal class Unexpected : ErrorKind
-			{
-				public string Item;
-
-				public Unexpected(string item) : base(Tags.Unexpected) => Item = item;
-			}
-
-			internal class MultiColon : ErrorKind
-			{
-				public string Item;
-
-				public MultiColon(string item) : base(Tags.MultiColon) => Item = item;
-			}
-
-			internal class MultiAt : ErrorKind
-			{
-				public string Item;
-				internal MultiAt(string item) : base(Tags.MultiAt) => Item = item;
-			}
-
-			internal class AtOutsideOr : ErrorKind
-			{
-				public string Item;
-				internal AtOutsideOr(string item) : base(Tags.AtOutsideOr) => Item = item;
-			}
-
-			internal class UnknownWrapper : ErrorKind
-			{
-				public char Item;
-				public UnknownWrapper(char item) : base(Tags.UnknownWrapper) => Item = item;
-			}
-
-			internal class NonTopLevel : ErrorKind
-			{
-				public string Item;
-				public NonTopLevel(string item) : base(Tags.NonTopLevel) => Item = item;
-			}
-
-			internal class Trailing : ErrorKind
-			{
-				public string Item;
-				public Trailing(string item) : base(Tags.Trailing) => Item = item;
-			}
-
-			internal class BadPubKey : ErrorKind
-			{
-				public FormatException Item;
-				public BadPubKey(FormatException item) : base(Tags.BadPubKey) => Item = item;
-			}
-
-			internal class MissingHash : ErrorKind
-			{
-				public uint256 Item;
-
-				public MissingHash(uint256 item) : base(Tags.MissingHash) => Item = item;
-			}
-
-			internal class MissingSig : ErrorKind
-			{
-				public PubKey Item;
-
-				public MissingSig(PubKey item) : base(Tags.MissingSig) => Item = item;
-			}
-
-			internal class RelativeLockTimeNotMet : ErrorKind
-			{
-				public uint Item;
-				public RelativeLockTimeNotMet(uint item) : base(Tags.RelativeLocktimeNotMet) => Item = item;
-			}
-
-			internal class AbsoluteLockTimeNotMet : ErrorKind
-			{
-				public uint Item;
-				public AbsoluteLockTimeNotMet(uint item) : base(Tags.AbsoluteLockTimeNotMet) => Item = item;
-			}
-
-			internal class TypeCheck : ErrorKind
-			{
-				public string Item;
-				public TypeCheck(string item) : base(Tags.TypeCheck) => Item = item;
-			}
-
-			internal class CompileError : ErrorKind
-			{
-				public Policy.CompilerException Item;
-
-				public CompileError(Policy.CompilerException item) : base (Tags.CompileError) => Item = item;
-			}
-
-			internal class InterpreterError : ErrorKind
-			{
-				public InterpreterError Item;
-
-				public InterpreterError(InterpreterError item) : base(Tags.InterpreterError) => Item = item;
-			}
 
+			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/Types/Correctness.cs b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
index 8aea31dd18..fcdc140229 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
@@ -3,6 +3,7 @@
 
 namespace NBitcoin.Scripting.Miniscript.Types
 {
+	[DebuggerDisplay("{" + nameof(DebugPrint) + "()}")]
 	internal class Correctness : IProperty<Correctness>
 	{
 		public readonly Base Base;
@@ -24,6 +25,9 @@ public Correctness(Base @base, Input input, bool disSatisfiable, bool unit)
 			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)) &&
@@ -51,7 +55,7 @@ public override Correctness FromTrue()
 			=> new Correctness(Base.B, Input.Zero, false, true);
 
 		public override Correctness FromFalse()
-			=> new Correctness(Base.B, Input.Zero, true, false);
+			=> new Correctness(Base.B, Input.Zero, true, true);
 
 		public override Correctness FromPk()
 			=> new Correctness(Base.K, Input.OneNonZero, true, true);
diff --git a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
index b921323594..0e66d1358f 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -68,7 +68,7 @@ public override Malleability FromTrue() =>
 			new Malleability(Dissat.None, false, true);
 
 		public override Malleability FromFalse() =>
-			new Malleability(Dissat.None, true, true);
+			new Malleability(Dissat.Unique, true, true);
 
 		public override Malleability FromPk() =>
 			new Malleability(Dissat.Unique, true, true);
diff --git a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
index 279e09bd19..44db74a491 100644
--- a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
@@ -6,6 +6,7 @@
 
 namespace NBitcoin.Scripting.Miniscript.Types
 {
+	[DebuggerDisplay("{" + nameof(DebugPrint) + "()}")]
 	public class MiniscriptFragmentType : IProperty<MiniscriptFragmentType>
 	{
 		internal readonly Correctness Correctness;
@@ -26,12 +27,16 @@ public bool IsSubtype(MiniscriptFragmentType other) =>
 
 		public override void SanityChecks()
 		{
-			Debug.Assert(!this.Correctness.DisSatisfiable || this.Malleability.Dissat != Dissat.None);
-			Debug.Assert(this.Malleability.Dissat == Dissat.None || this.Correctness.Base != Base.V);
-			Debug.Assert(this.Malleability.Safe || this.Correctness.Base != Base.K);
-			Debug.Assert(this.Malleability.NonMalleable || this.Correctness.Input != Input.Zero);
+			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(
diff --git a/NBitcoin/Scripting/Miniscript/Types/Property.cs b/NBitcoin/Scripting/Miniscript/Types/Property.cs
index 718adb9043..c8dd242b15 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Property.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Property.cs
@@ -119,7 +119,7 @@ T GetChild(Terminal<TPk, TPKh> sub, int n)
 				case Terminal<TPk, TPKh>.OrI self:
 					var orIL = GetChild(self.Item1.Node, 0);
 					var orIR = GetChild(self.Item2.Node, 1);
-					return new T().OrC(orIL, orIR);
+					return new T().OrI(orIL, orIR);
 				case Terminal<TPk, TPKh>.AndOr self:
 					var a = GetChild(self.Item1.Node, 0);
 					var b = GetChild(self.Item2.Node, 1);

From d75e079a4bde6e7a17af5c487c133117c9a27d05 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Wed, 13 Nov 2019 01:00:56 +0900
Subject: [PATCH 26/50] Update

---
 NBitcoin.Tests/MiniscriptTests.cs             | 28 +++++++++----------
 NBitcoin/Scripting/Miniscript/AstElem.cs      | 21 +++++++++-----
 NBitcoin/Scripting/Miniscript/Miniscript.cs   | 22 +++++++++------
 .../Miniscript/Types/Malleability.cs          |  2 +-
 .../Scripting/Miniscript/Types/Property.cs    |  6 +++-
 5 files changed, 47 insertions(+), 32 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 2e8a2d5ca0..49b2a801b3 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -27,7 +27,6 @@ public class MiniscriptTests
 		public static TheoryData<string, string, bool, bool, bool, uint, uint> MSAttributeTestCase =>
 			new TheoryData<string, string, bool, bool, bool, uint, uint>
 			{
-				/*
 				{
 					"lltvln:after(1231488000)",
 					"6300676300676300670400046749b1926869516868",
@@ -131,7 +130,6 @@ public class MiniscriptTests
 					"82012088aa208a35d9ca92a48eaade6f53a64985e9e2afeb74dcf8acb4c3721e0dc7e4294b2587640350c300b2696782012088aa20939894f70e6c3a25da75da0cc2071b4076d9b006563cf635986ada2e93c0d735886804ff64cd1db1",
 					true, false, false, 14, 2
 				},
-				*/
 				{
 					"andor(hash256(5f8d30e655a7ba0d7596bb3ddfb1d2d20390d23b1845000e1e118b3be1b3f040),j:and_v(v:hash160(3a2bff0da9d96868e66abc4427bea4691cf61ccd),older(4194305)),ripemd160(44d90e2d3714c8663b632fcf0f9d5f22192cc4c8))",
 					"82012088aa205f8d30e655a7ba0d7596bb3ddfb1d2d20390d23b1845000e1e118b3be1b3f040876482012088a61444d90e2d3714c8663b632fcf0f9d5f22192cc4c8876782926382012088a9143a2bff0da9d96868e66abc4427bea4691cf61ccd8803010040b26868",
@@ -194,20 +192,20 @@ public void MiniscriptAttributesTest(
 			string msStr, string expectedHex, bool valid, bool nonMalleable,
 			bool needSig, uint ops, uint _stack)
 		{
-			if (valid)
+			Miniscript<PubKey, uint160> ms;
+			Console.WriteLine($"Testing {msStr}");
+			try
 			{
-				Miniscript<PubKey, uint160> ms;
-				Console.WriteLine($"Testing {msStr}");
-				try
-				{
-					ms = Miniscript<PubKey, uint160>.Parse(msStr);
-					Assert.Equal(ms.ToScript().ToHex(), expectedHex);
-					Assert.Equal(ms.Type.Malleability.NonMalleable, nonMalleable);
-					Assert.Equal(ms.Type.Malleability.Safe, needSig);
-					Assert.Equal(ms.Ext.OpsCountSat, ops);
-				}
-				catch (MiniscriptException)
-				{ }
+				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);
+			}
+			catch (ParsingException)
+			{
+				Assert.False(valid);
 			}
 		}
 
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index f3e5983ce2..4866c06179 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -99,6 +99,7 @@ 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
 		{
@@ -514,7 +515,7 @@ private List<Op> ToOpList()
 					return l;
 				case Ripemd160 self:
 					l.Add(OpcodeType.OP_SIZE);
-					l.Add(Op.GetPushOp(20));
+					l.Add(Op.GetPushOp(32));
 					l.Add(OpcodeType.OP_EQUALVERIFY);
 					l.Add(OpcodeType.OP_RIPEMD160);
 					l.Add(Op.GetPushOp(self.Item.ToBytes()));
@@ -522,7 +523,7 @@ private List<Op> ToOpList()
 					return l;
 				case Hash160 self:
 					l.Add(OpcodeType.OP_SIZE);
-					l.Add(Op.GetPushOp(20));
+					l.Add(Op.GetPushOp(32));
 					l.Add(OpcodeType.OP_EQUALVERIFY);
 					l.Add(OpcodeType.OP_HASH160);
 					l.Add(Op.GetPushOp(self.Item.ToBytes()));
@@ -591,6 +592,12 @@ private List<Op> ToOpList()
 					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());
@@ -618,7 +625,7 @@ private List<Op> ToOpList()
 					l.Add(OpcodeType.OP_CHECKMULTISIG);
 					return l;
 			}
-			throw new Exception(("Unreachable!"));
+			throw new Exception(($"Unreachable! {this}"));
 		}
 
 		public int ScriptSize()
@@ -1333,19 +1340,19 @@ internal static Terminal<TPk, TPKh> FromTree(Tree top)
 					break;
 				case "sha256":
 					if (top.Args.Count == 1)
-						unwrapped = Tree.Terminal(top.Args[0], x => NewSha256(uint256.Parse(x)));
+						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(uint256.Parse(x.ToCharArray().Reverse().ToString())));
+						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(uint160.Parse(x)));
+						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(uint160.Parse(x)));
+						unwrapped = Tree.Terminal(top.Args[0], x => NewHash160(new uint160(Hex.DecodeData(x), true)));
 					break;
 				case "1":
 					if (top.Args.Count == 0)
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index ea729819dd..6047cc0edc 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using NBitcoin.Scripting.Miniscript.Types;
+using NBitcoin.Scripting.Parser;
 
 namespace NBitcoin.Scripting.Miniscript
 {
@@ -47,14 +48,19 @@ public static Miniscript<TPk, TPKh> FromTree(Tree t)
 		public static Miniscript<TPk, TPKh> Parse(string str)
 		{
 			var inner = Terminal<TPk, TPKh>.FromTree(Tree.Parse(str));
-			var ms = new Miniscript<TPk, TPKh>(
-				Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(inner),
-				inner,
-				Property<ExtData, TPk, TPKh>.TypeCheck(inner)
-				);
-			if (ms.Type.Correctness.Base != Base.B)
-				throw new MiniscriptException.NonTopLevel(ms.Type.Correctness.Base.ToString("G"));
-			return ms;
+			try
+			{
+				var ms = new Miniscript<TPk, TPKh>(
+					Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(inner),
+					inner,
+					Property<ExtData, TPk, TPKh>.TypeCheck(inner)
+					);
+				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() =>
diff --git a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
index 0e66d1358f..e33705b08d 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -83,7 +83,7 @@ public override Malleability FromTime(uint time) =>
 			new Malleability(Dissat.None, false, true);
 
 		public override Malleability FromHash() =>
-			new Malleability(Dissat.None, false, true);
+			new Malleability(Dissat.Unknown, false, true);
 
 		public override Malleability CastAlt() =>
 			this;
diff --git a/NBitcoin/Scripting/Miniscript/Types/Property.cs b/NBitcoin/Scripting/Miniscript/Types/Property.cs
index c8dd242b15..51adc4dd42 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Property.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Property.cs
@@ -84,6 +84,8 @@ T GetChild(Terminal<TPk, TPKh> sub, int n)
 					return new T().FromHash256();
 				case Terminal<TPk, TPKh>.Ripemd160 self:
 					return new T().FromRipemd160();
+				case Terminal<TPk, TPKh>.Hash160 self:
+					return new T().FromHash160();
 				case Terminal<TPk, TPKh>.Alt self:
 					return GetChild(self.Item.Node, 0).CastAlt();
 				case Terminal<TPk, TPKh>.Swap self:
@@ -96,6 +98,8 @@ T GetChild(Terminal<TPk, TPKh> sub, int n)
 					return GetChild(self.Item.Node, 0).CastVerify();
 				case Terminal<TPk, TPKh>.NonZero self:
 					return GetChild(self.Item.Node, 0).CastNonZero();
+				case Terminal<TPk, TPKh>.ZeroNotEqual self:
+					return GetChild(self.Item.Node, 0).CastZeroNotEqual();
 				case Terminal<TPk, TPKh>.AndB self:
 					var andBL = GetChild(self.Item1.Node, 0);
 					var andBR = GetChild(self.Item2.Node, 1);
@@ -139,7 +143,7 @@ T GetChild(Terminal<TPk, TPKh> sub, int n)
 						new T().Threshold((int)self.Item1, self.Item2.Length, (n) =>
 							GetChild(self.Item2[n].Node, (int)n));
 			}
-			throw new Exception("Unreachable!");;
+			throw new Exception($"Unreachable! {fragment}");;
 		}
 	}
 }

From a06e13f0345b00ec8c0f9bb0f1e3f94f6890e01d Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Wed, 13 Nov 2019 01:23:49 +0900
Subject: [PATCH 27/50] Update

---
 NBitcoin.Tests/MiniscriptTests.cs           | 7 +++----
 NBitcoin/Scripting/Miniscript/AstElem.cs    | 6 ++++--
 NBitcoin/Scripting/Miniscript/Miniscript.cs | 2 +-
 3 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 49b2a801b3..ec781f1e1c 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -135,7 +135,6 @@ public class MiniscriptTests
 					"82012088aa205f8d30e655a7ba0d7596bb3ddfb1d2d20390d23b1845000e1e118b3be1b3f040876482012088a61444d90e2d3714c8663b632fcf0f9d5f22192cc4c8876782926382012088a9143a2bff0da9d96868e66abc4427bea4691cf61ccd8803010040b26868",
 					true, false, false, 20, 2
 				},
-				/*
 				{
 					"or_i(c:and_v(v:after(500000),pk(02c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5)),sha256(d9147961436944f43cd99d28b2bbddbf452ef872b30c8279e255e7daafc7f946))",
 					"630320a107b1692102c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5ac6782012088a820d9147961436944f43cd99d28b2bbddbf452ef872b30c8279e255e7daafc7f9468768",
@@ -193,7 +192,6 @@ public void MiniscriptAttributesTest(
 			bool needSig, uint ops, uint _stack)
 		{
 			Miniscript<PubKey, uint160> ms;
-			Console.WriteLine($"Testing {msStr}");
 			try
 			{
 				ms = Miniscript<PubKey, uint160>.Parse(msStr);
@@ -202,10 +200,11 @@ public void MiniscriptAttributesTest(
 				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)
+			catch (ParsingException ex)
 			{
-				Assert.False(valid);
+				Assert.False(valid, ex.ToString());
 			}
 		}
 
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 4866c06179..11c5e7204c 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -1415,14 +1415,16 @@ internal static Terminal<TPk, TPKh> FromTree(Tree top)
 						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);
-					return NewThresh(k, subs);
+					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));
-					return NewThreshM(km, subsm);
+					unwrapped = NewThreshM(km, subsm);
+					break;
 			}
 			if (unwrapped is null)
 				throw new ParsingException($"{top.Name}({top.Args.Count} args) while parsing Miniscript");
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index 6047cc0edc..f25ea262d1 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -47,9 +47,9 @@ public static Miniscript<TPk, TPKh> FromTree(Tree t)
 		}
 		public static Miniscript<TPk, TPKh> Parse(string str)
 		{
-			var inner = Terminal<TPk, TPKh>.FromTree(Tree.Parse(str));
 			try
 			{
+				var inner = Terminal<TPk, TPKh>.FromTree(Tree.Parse(str));
 				var ms = new Miniscript<TPk, TPKh>(
 					Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(inner),
 					inner,

From a5a162f4b2e1c10bc7148c294e7b142758b04b78 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Wed, 13 Nov 2019 01:44:24 +0900
Subject: [PATCH 28/50] Update

---
 NBitcoin.Tests/MiniscriptTests.cs              | 1 +
 NBitcoin/Scripting/Miniscript/Types/ExtData.cs | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index ec781f1e1c..bc37c03c10 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -120,6 +120,7 @@ public class MiniscriptTests
 					"82012088a8209267d3dbed802941483f1afa2a6bc68de5f653128aca9bf1461c5d0a3ad36ed28764512102c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db51af682103acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbeac",
 					true, false, true, 8, 2
 				},
+				/*
 				{
 					"c:and_v(or_c(thresh_m(2,036d2b085e9e382ed10b69fc311a03f8641ccfff21574de0927513a49d9a688a00,02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5),v:ripemd160(1b0f3c404d12075c68c938f9f60ebea4f74941a0)),pk(03fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556))",
 					"5221036d2b085e9e382ed10b69fc311a03f8641ccfff21574de0927513a49d9a688a002102352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d552ae6482012088a6141b0f3c404d12075c68c938f9f60ebea4f74941a088682103fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556ac",
diff --git a/NBitcoin/Scripting/Miniscript/Types/ExtData.cs b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
index 0268768193..ac3c8e264c 100644
--- a/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
@@ -418,7 +418,7 @@ public override ExtData Threshold(int k, int n, Func<int, ExtData> subCk)
 			{
 				opsCountSatVec.Sort();
 				opsCountSatVec.Reverse();
-				Func<ulong?, double> summer = v => v ?? 0UL;
+				Func<ulong?, double> summer = v => v.Value;
 				sum = (ulong)opsCountSatVec.Skip(remainingSat).Sum(summer);
 			}
 			return new ExtData(
@@ -426,7 +426,7 @@ public override ExtData Threshold(int k, int n, Func<int, ExtData> subCk)
 				pkCost + (ulong)n - 1UL,
 				true,
 				opsCountStatic + ((ulong)n - 1UL) + 1UL,
-				opsCountSat + ((ulong)n - 1UL) + (sum + opsCountNSatSum),
+				opsCountSat + ((ulong)n - 1UL) + 1UL + (sum + opsCountNSatSum),
 				opsCountNSat + ((ulong)n - 1UL) + 1UL
 				);
 		}

From 7ec6ae6f1c299b199faaf3bc49539c485a3a2589 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Wed, 13 Nov 2019 02:07:09 +0900
Subject: [PATCH 29/50] Pass every unit tests for miniscript

---
 NBitcoin.Tests/MiniscriptTests.cs                   | 3 ---
 NBitcoin/Scripting/Miniscript/MiniscriptKey.cs      | 3 ++-
 NBitcoin/Scripting/Miniscript/Types/Malleability.cs | 2 +-
 3 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index bc37c03c10..d2fd557387 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -120,7 +120,6 @@ public class MiniscriptTests
 					"82012088a8209267d3dbed802941483f1afa2a6bc68de5f653128aca9bf1461c5d0a3ad36ed28764512102c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db51af682103acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbeac",
 					true, false, true, 8, 2
 				},
-				/*
 				{
 					"c:and_v(or_c(thresh_m(2,036d2b085e9e382ed10b69fc311a03f8641ccfff21574de0927513a49d9a688a00,02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5),v:ripemd160(1b0f3c404d12075c68c938f9f60ebea4f74941a0)),pk(03fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556))",
 					"5221036d2b085e9e382ed10b69fc311a03f8641ccfff21574de0927513a49d9a688a002102352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d552ae6482012088a6141b0f3c404d12075c68c938f9f60ebea4f74941a088682103fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556ac",
@@ -156,7 +155,6 @@ public class MiniscriptTests
 					"2103daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729ac64006763006703e2e440b2686b60b26c9a68",
 					true, true, true, 12, 2
 				},
-				/*
 				{
 					"c:or_i(and_v(v:older(16),pk_h(9fc5dbe5efdce10374a4dd4053c93af540211718)),pk_h(2fbd32c8dd59ee7c17e66cb6ebea7e9846c3040f))",
 					"6360b26976a9149fc5dbe5efdce10374a4dd4053c93af540211718886776a9142fbd32c8dd59ee7c17e66cb6ebea7e9846c3040f8868ac",
@@ -182,7 +180,6 @@ public class MiniscriptTests
 					"6376a914fcd35ddacad9f2d5be5e464639441c6065e6955d88ac6476a91406afd46bcdfd22ef94ac122aa11f241244a37ecc886776a9149652d86bedf43ad264362e6e6eba6eb7645081278868672102d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e68ac",
 					true, true, true, 17, 5
 				},
-				*/
 			};
 
 		[Theory]
diff --git a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
index 3b645b299a..4d1333ca48 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
@@ -94,6 +94,7 @@ public static 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();
@@ -113,7 +114,7 @@ public static TPKh ParseHash(string str)
 		{
 			var t = new TPKh();
 			if (t is uint160)
-				return uint160.Parse(str) as TPKh;
+				return new uint160(Hex.DecodeData(str), true) as TPKh;
 			if (t is MiniscriptStringKeyHash)
 				return MiniscriptStringKeyHash.Parse(str) as TPKh;
 			throw new NotSupportedException();
diff --git a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
index e33705b08d..9b682a89d3 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -179,7 +179,7 @@ public override Malleability OrC(Malleability left, Malleability right) =>
 				left.NonMalleable
 				&& left.Dissat == Dissat.Unique
 				&& right.NonMalleable
-				&& (left.Safe && right.Safe)
+				&& (left.Safe || right.Safe)
 				);
 
 		public override Malleability OrI(Malleability left, Malleability right) =>

From 54701d6fafdf733023fadb1ba9f026e10a618d9e Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Wed, 13 Nov 2019 02:40:38 +0900
Subject: [PATCH 30/50] only generate positive number for times

---
 NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs   | 10 ++++++----
 NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs |  9 ++++++---
 2 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs b/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
index 2177c3b33f..48b01ec65c 100644
--- a/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
+++ b/NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs
@@ -17,6 +17,7 @@ public class ArbitraryPubKeyConcretePolicy : Arbitrary<ConcretePolicy<PubKey, ui
 		{
 			public override Gen<ConcretePolicy<PubKey, uint160>> Generator => Gen.Sized(ConcretePolicyGen);
 
+			/*
 			public override IEnumerable<ConcretePolicy<PubKey, uint160>> Shrinker(ConcretePolicy<PubKey, uint160> parent)
 			{
 				switch (parent)
@@ -55,6 +56,7 @@ public override IEnumerable<ConcretePolicy<PubKey, uint160>> Shrinker(ConcretePo
 						yield break;
 				}
 			}
+			*/
 
 			private static Gen<ConcretePolicy<PubKey, uint160>> ConcretePolicyGen(int size)
 			{
@@ -84,12 +86,12 @@ from inner in CryptoGenerator.PublicKey()
 
 			private static Gen<ConcretePolicy<PubKey, uint160>> AfterGen()
 				=>
-					from t in Arb.Generate<uint>()
-					select ConcretePolicy<PubKey, uint160>.NewAfter(t);
+					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<uint>()
-					select ConcretePolicy<PubKey, uint160>.NewOlder(t);
+					from t in Arb.Generate<PositiveInt>()
+					select ConcretePolicy<PubKey, uint160>.NewOlder((uint)t.Get);
 
 			private static Gen<ConcretePolicy<PubKey, uint160>> Sha256Gen()
 				=>
diff --git a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
index 5ca615bd79..1e6f5591c7 100644
--- a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
+++ b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
@@ -16,7 +16,7 @@ public MiniscriptPropertyTests()
 			Arb.Register<ConcretePolicyGenerator>();
 		}
 
-		[Property(MaxTest = 100)]
+		[Property(MaxTest = 12)]
 		[Trait("UnitTest", "UnitTest")]
 		public void ShouldBidirectionallyConvertConcretePolicyToString(ConcretePolicy<PubKey, uint160> p)
 		{
@@ -27,16 +27,19 @@ public void ShouldBidirectionallyConvertConcretePolicyToString(ConcretePolicy<Pu
 			Assert.Equal(p.GetHashCode(), c.GetHashCode());
 		}
 
-		[Property(MaxTest = 100)]
+		[Property(MaxTest = 12)]
+		[Trait("UnitTest", "UnitTest")]
 		public void ShouldCompileConcretePolicy(ConcretePolicy<PubKey, uint160> p)
 		{
-			Console.WriteLine(p);
 			var t = p.IsSafeNonMalleable();
 			var isSafe = t.Item1;
 			var IsNonMalleable = t.Item2;
+				Console.WriteLine($"Compiling {p}");
 			if (isSafe && IsNonMalleable)
 			{
+				Console.WriteLine($"it is safe and non malleable");
 				var ms = p.Compile();
+				Console.WriteLine($"Compiled {ms}");
 			}
 			else
 			{

From 007715ed3c49daeb8df63551833f24d2093b66cf Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Thu, 14 Nov 2019 22:38:41 +0900
Subject: [PATCH 31/50] Fix bug in compiler

---
 NBitcoin.Tests/MiniscriptTests.cs             |  19 ++++
 NBitcoin/Scripting/Miniscript/AstElem.cs      | 102 ++++++++++++++++++
 .../Scripting/Miniscript/Policy/Compiler.cs   |  54 +++++++---
 .../Miniscript/Policy/ConcretePolicy.cs       |  11 +-
 .../Types/MiniscriptFragmentType.cs           |  21 +++-
 5 files changed, 185 insertions(+), 22 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index d2fd557387..4f9645bffc 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -259,5 +259,24 @@ public void ConcretePolicyUnitTest()
 			var concreteP2_2 = ConcretePolicy<PubKey, uint160>.Parse(testCase2);
 			Assert.Equal(concreteP2_1.GetHashCode(), concreteP2_2.GetHashCode());
 		}
+
+		private void PolicyCompileLiftCheck(string s)
+		{
+			var policy = ConcretePolicy<PubKey, uint160>.Parse(s);
+			var ms = policy.Compile();
+			Assert.Equal(policy.Lift(), ms.Lift());
+		}
+
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void CompilerUnitTest()
+		{
+			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck("after(9)"));
+			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck("older(1)"));
+			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck("sha256(1111111111111111111111111111111111111111111111111111111111111111)"));
+			PolicyCompileLiftCheck($"and(pk({PubKeys[0]}),pk({PubKeys[1]}))");
+			// PolicyCompileLiftCheck($"or(pk({PubKeys[0]}),pk({PubKeys[1]}))");
+			// PolicyCompileLiftCheck($"thresh(2,pk({PubKeys[0]}),pk({PubKeys[1]}),pk({PubKeys[2]}))");
+		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 11c5e7204c..c4e30522b7 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -462,6 +462,108 @@ public bool Equals(Terminal<TPk, TPKh> other)
 			}
 			throw new Exception("Unreachable!");
 		}
+
+		public override int GetHashCode()
+		{
+
+			int num = 0;
+			switch (this.Tag)
+			{
+				case Tags.True: return Tags.True;
+				case Tags.False: return Tags.False;
+			}
+
+			switch (this)
+			{
+				case Pk self:
+					num = Tags.Pk;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case PkH self:
+					num = Tags.PkH;
+					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 Alt self:
+					num = Tags.Alt;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Swap self:
+					num = Tags.Swap;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Check self:
+					num = Tags.Check;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case DupIf self:
+					num = Tags.DupIf;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case Verify self:
+					num = Tags.Verify;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case NonZero self:
+					num = Tags.NonZero;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case ZeroNotEqual self:
+					num = Tags.ZeroNotEqual;
+					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
+				case AndV self:
+					num = Tags.AndV;
+					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
+					return -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
+				case AndB self:
+					num = Tags.AndB;
+					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
+					return -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
+				case AndOr self:
+					num = Tags.AndOr;
+					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
+					num = -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
+					return -1640531527 + self.Item3.GetHashCode() + ((num << 6) + (num >> 2));
+				case OrB self:
+					num = Tags.OrB;
+					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
+					return -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
+				case OrD self:
+					num = Tags.OrD;
+					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
+					return -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
+				case OrC self:
+					num = Tags.OrC;
+					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
+					return -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
+				case OrI self:
+					num = Tags.OrI;
+					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
+					return -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
+				case Thresh self:
+					num = Tags.Thresh;
+					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
+					foreach (var sub in self.Item2)
+						num = -1640531527 + sub.GetHashCode() + ((num << 6) + (num >> 2));
+					return num;
+				case ThreshM self:
+					num = Tags.ThreshM;
+					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
+					foreach (var sub in self.Item2)
+						num = -1640531527 + sub.GetHashCode() + ((num << 6) + (num >> 2));
+					return num;
+			}
+			throw new Exception("Unreachable!");
+		}
 		#endregion
 
 		public Script ToScript() =>
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index 3d4c86c2e2..481e714980 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -26,7 +26,7 @@ private CompilerException(string msg) : base(msg) {}
 	/// This represents the state of the best possible compilation
 	/// of a given policy(implicitly keyed).
 	/// </summary>
-	internal class CompilationKey
+	internal class CompilationKey : IEquatable<CompilationKey>
 	{
 		/// <summary>
 		/// The type of the compilation result
@@ -60,6 +60,21 @@ internal CompilationKey(MiniscriptFragmentType type, bool expensiveVerify, doubl
 			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>
@@ -431,7 +446,8 @@ private static bool InsertElem(
 			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);
@@ -441,12 +457,14 @@ private static bool InsertElem(
 			{
 				// if the element is not worse any element in the map, remove elements
 				// whose subtype is the current element and have worse cost.
-				map = map.Where(kv =>
+				var keysToRemove = map.Where(kv =>
 				{
 					var existingElementsCost = kv.Value.Cost1d(satProb, dissatProb);
-					return !((elemKey.IsSubtype(kv.Key)) && existingElementsCost >= elemCost);
-				}).ToDictionary(kv => kv.Key, kv => kv.Value);
-				map.Add(elemKey, astElemExt);
+					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;
@@ -456,7 +474,11 @@ private static bool InsertElem(
 		/// 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
+		/// 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>
@@ -470,21 +492,22 @@ private static void InsertElemClosure(
 			double? dissatProb
 		)
 		{
-			var castStack = new Stack<AstElemExt<TPk, TPKh>>();
+			var castStack = new Queue<AstElemExt<TPk, TPKh>>();
 			if (InsertElem(map, astElemExt, satProb, dissatProb))
-				castStack.Push(astElemExt);
+				castStack.Enqueue(astElemExt);
 
 			while (castStack.Count != 0)
 			{
-				var casts = Cast<TPk, TPKh>.GetAllCasts(castStack.Pop());
+				var casts = Cast<TPk, TPKh>.GetAllCasts(castStack.Dequeue());
 				foreach (var c in casts)
 				{
+					AstElemExt<TPk, TPKh> newExt = null;
 					try
 					{
-						var newExt = c.InvokeCast();
-						if (InsertElem(map, newExt, satProb, dissatProb))
-							castStack.Push(newExt);
-					} catch (FragmentPropertyException e) {}
+						newExt = c.InvokeCast();
+					} catch (FragmentPropertyException ) { }
+					if (!(newExt is null) && InsertElem(map, newExt, satProb, dissatProb))
+						castStack.Enqueue(newExt);
 				}
 			}
 		}
@@ -810,10 +833,9 @@ Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> binFunc
 					{
 						var newExt = AstElemExt<TPk, TPKh>.Binary(ast, l, r);
 						InsertBestWrapped(policyCache, policy, ret, newExt, satProb, dissatProb);
-					} catch (FragmentPropertyException ex) {}
+					} catch (FragmentPropertyException) {}
 				}
 			}
-			throw new NotImplementedException();
 		}
 
 		private static void CompileTernary(
diff --git a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
index ad9df69479..38927ba2b6 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/ConcretePolicy.cs
@@ -237,6 +237,12 @@ public override int GetHashCode()
 			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;
@@ -278,11 +284,6 @@ public AbstractPolicy<TPk, TPKh> Lift()
 
 		}
 
-		public override bool Equals(object obj) =>
-			Equals(obj as ConcretePolicy<TPk, TPKh>);
-
-		#endregion
-
 		# region to/from string
 		public override string ToString() =>
 			ToStringCore(new StringBuilder()).ToString();
diff --git a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
index 44db74a491..686aa89157 100644
--- a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
@@ -7,7 +7,7 @@
 namespace NBitcoin.Scripting.Miniscript.Types
 {
 	[DebuggerDisplay("{" + nameof(DebugPrint) + "()}")]
-	public class MiniscriptFragmentType : IProperty<MiniscriptFragmentType>
+	public class MiniscriptFragmentType : IProperty<MiniscriptFragmentType>, IEquatable<MiniscriptFragmentType>
 	{
 		internal readonly Correctness Correctness;
 
@@ -221,5 +221,24 @@ public override MiniscriptFragmentType Threshold(int k, int n, Func<int, Miniscr
 				new MiniscriptFragmentType(
 					new Correctness().Threshold(k, n, i => func(i).Correctness),
 					new Malleability().Threshold(k, n , i => func(i).Malleability));
+
+
+		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)
+				&& (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 + Malleability.NonMalleable.GetHashCode() + ((num << 6) + (num >> 2));
+			num = -1640531527 + Malleability.Safe.GetHashCode() + ((num << 6) + (num >> 2));
+			return num;
+		}
 	}
 }

From 7b70619547f71283d6f85f939b84d2c332967fe6 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Fri, 15 Nov 2019 02:28:16 +0900
Subject: [PATCH 32/50] Speed up compiling by not throwing error

---
 NBitcoin/Scripting/Miniscript/Miniscript.cs   |   2 +-
 .../Scripting/Miniscript/Policy/Compiler.cs   | 399 +++++++++++-------
 .../Scripting/Miniscript/Types/Correctness.cs | 396 +++++++++++++----
 .../Scripting/Miniscript/Types/ExtData.cs     | 153 ++++---
 .../Types/FragmentPropertyException.cs        |  12 +-
 .../Scripting/Miniscript/Types/IProperty.cs   |  45 +-
 .../Miniscript/Types/Malleability.cs          | 160 ++++---
 .../Types/MiniscriptFragmentType.cs           | 319 ++++++++++----
 .../Scripting/Miniscript/Types/Property.cs    |  71 +++-
 9 files changed, 1081 insertions(+), 476 deletions(-)

diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index f25ea262d1..b5ef85e683 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -11,7 +11,7 @@ public partial class Miniscript<TPk, TPKh>
 		where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		internal readonly Terminal<TPk, TPKh> Node;
-		public readonly MiniscriptFragmentType Type;
+		internal readonly MiniscriptFragmentType Type;
 
 		/// <summary>
 		/// Additional information helpful for extra analysis.
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index 481e714980..d881af100b 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -134,111 +134,158 @@ public override CompilerExtData FromHash()
 		public override CompilerExtData FromTime(uint time) =>
 			new CompilerExtData(null, 0.0, null);
 
-		public override CompilerExtData CastAlt()
-			=> new CompilerExtData(null, SatisfyCost, DissatCost);
+		public override bool TryCastAlt(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, DissatCost);
+			return true;
+		}
 
-		public override CompilerExtData CastSwap() =>
-			new CompilerExtData(null, SatisfyCost, DissatCost);
+		public override bool TryCastSwap(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, DissatCost);
+			return true;
+		}
 
-		public override CompilerExtData CastCheck()
-			=> new CompilerExtData(null, SatisfyCost, DissatCost);
+		public override bool TryCastCheck(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, DissatCost);
+			return true;
+		}
 
-		public override CompilerExtData CastDupIf()
-			=> new CompilerExtData(null, 2.0 + SatisfyCost, 1.0);
+		public override bool TryCastDupIf(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, 2.0 + SatisfyCost, 1.0);
+			return true;
+		}
 
-		public override CompilerExtData CastVerify()
-			=> new CompilerExtData(null, SatisfyCost, null);
+		public override bool TryCastVerify(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, null);
+			return true;
+		}
 
-		public override CompilerExtData CastNonZero()
-			=> new CompilerExtData(null, SatisfyCost, 1.0);
+		public override bool TryCastNonZero(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, 1.0);
+			return true;
+		}
 
-		public override CompilerExtData CastZeroNotEqual()
-			=> new CompilerExtData(null, SatisfyCost, DissatCost);
+		public override bool TryCastZeroNotEqual(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, DissatCost);
+			return true;
+		}
 
-		public override CompilerExtData CastTrue()
-			=> new CompilerExtData(null, SatisfyCost, null);
+		public override bool TryCastTrue(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, null);
+			return true;
+		}
 
-		public override CompilerExtData CastOrIFalse()
-			=> new CompilerExtData(null, SatisfyCost, null);
+		public override bool TryCastOrIFalse(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, SatisfyCost, null);
+			return true;
+		}
 
-		public override CompilerExtData CastUnLikely()
-			=> new CompilerExtData(null, 2.0 + SatisfyCost, 1.0);
+		public override bool TryCastUnLikely(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, 2.0 + SatisfyCost, 1.0);
+			return true;
+		}
 
-		public override CompilerExtData CastLikely()
-			=> new CompilerExtData(null, 1.0 + SatisfyCost, 2.0);
+		public override bool TryCastLikely(out CompilerExtData result, List<FragmentPropertyException> error)
+		{
+			result = new CompilerExtData(null, 1.0 + SatisfyCost, 2.0);
+			return true;
+		}
 
-		public override CompilerExtData AndB(CompilerExtData l, CompilerExtData r)
-			=> new CompilerExtData(null, l.SatisfyCost + r.SatisfyCost,
+		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 CompilerExtData AndV(CompilerExtData l, CompilerExtData r)
-			=> new CompilerExtData(null, l.SatisfyCost + r.SatisfyCost, null);
+		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 CompilerExtData OrB(CompilerExtData left, CompilerExtData right)
+		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.
-			return new CompilerExtData(
+			result = new CompilerExtData(
 				null,
 				lProb * (left.SatisfyCost + right.DissatCost.Value) + rProb * (right.SatisfyCost + left.DissatCost.Value),
 				left.DissatCost + right.DissatCost
 				);
+			return true;
 		}
 
-		public override CompilerExtData OrD(CompilerExtData left, CompilerExtData right)
+		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 = left.BranchProb.Value; // and for right branch.
-			return new CompilerExtData(
+			result = new CompilerExtData(
 				null,
 				(lProb * left.SatisfyCost + rProb * (right.SatisfyCost + left.DissatCost.Value)),
 				right.DissatCost + left.DissatCost
 				);
+			return true;
 		}
 
-		public override CompilerExtData OrC(CompilerExtData left, CompilerExtData right)
+		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.
-			return new CompilerExtData(
+			result = new CompilerExtData(
 				null,
 				lProb * (left.SatisfyCost + right.DissatCost.Value) +
 				rProb * (right.SatisfyCost + left.DissatCost.Value),
 				null
 			);
+			return true;
 		}
 
-		public override CompilerExtData OrI(CompilerExtData left, CompilerExtData right)
+		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.
-			return new CompilerExtData(
+			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 CompilerExtData AndOr(CompilerExtData a, CompilerExtData b, CompilerExtData c)
+		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;
-			return new CompilerExtData(
+			result = new CompilerExtData(
 				null,
 				aProb * (a.SatisfyCost + b.SatisfyCost)
 				+ cProb * (aDis + c.SatisfyCost),
 				aDis + c.DissatCost
 				);
+			return true;
 		}
 
-		public override CompilerExtData AndN(CompilerExtData l, CompilerExtData r)
-			=> new CompilerExtData(null, l.SatisfyCost + r.SatisfyCost, l.DissatCost);
+		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 CompilerExtData Threshold(int k, int n, Func<int, CompilerExtData> subCk)
+		public override bool TryThreshold(int k, int n, Func<int, CompilerExtData> subCk, out CompilerExtData result, List<FragmentPropertyException> error)
 		{
 			var kOverN = k;
 			var satisfyCost = 0.0;
@@ -250,10 +297,11 @@ public override CompilerExtData Threshold(int k, int n, Func<int, CompilerExtDat
 				dissatisfyCost += sub.DissatCost.Value;
 			}
 
-			return new CompilerExtData(
+			result = new CompilerExtData(
 				null,
 				satisfyCost * kOverN + dissatisfyCost * (1.0 - kOverN),
 				dissatisfyCost);
+			return true;
 		}
 	}
 
@@ -329,100 +377,157 @@ AstElemExt<TPk, TPKh> c
 
 			return new AstElemExt<TPk, TPKh>(compilerExtData, new Miniscript<TPk, TPKh>(ty, ast, ext));
 		}
-	}
-
-	internal class Cast<TPk, TPKh>
-		where TPk : class, IMiniscriptKey<TPKh>, new()
-		where TPKh : class, IMiniscriptKeyHash, new()
-	{
-		public Func<Terminal<TPk, TPKh>> Node;
-		public Func<MiniscriptFragmentType> AstType;
-		public Func<ExtData> ExtData;
-		public Func<CompilerExtData> CompilerExtData;
-
-		public Cast(Func<ExtData> extData, Func<MiniscriptFragmentType> astType, Func<Terminal<TPk, TPKh>> node, Func<CompilerExtData> compilerExtData)
+		public List<AstElemExt<TPk, TPKh>> GetAllCasts()
 		{
-			ExtData = extData;
-			AstType = astType;
-			Node = node;
-			CompilerExtData = compilerExtData;
-		}
-
-		public AstElemExt<TPk, TPKh> InvokeCast()
-			=>
-				new AstElemExt<TPk, TPKh>(
-					compilerExtData: CompilerExtData.Invoke(),
-					ms: new Miniscript<TPk, TPKh>(
-						AstType.Invoke(),
-						Node.Invoke(),
-						ExtData.Invoke()
-
-					));
-
-		public static List<Cast<TPk, TPKh>> GetAllCasts(AstElemExt<TPk, TPKh> ast)
-			=> new List<Cast<TPk, TPKh>>()
+			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)
+			    )
 			{
-				new Cast<TPk, TPKh>(
-					ast.Ms.Ext.CastCheck,
-					ast.Ms.Type.CastCheck,
-					() => Terminal<TPk, TPKh>.NewCheck(ast.Ms),
-					ast.CompExtData.CastCheck
-				),
-				new Cast<TPk, TPKh>(
-					ast.Ms.Ext.CastDupIf,
-					ast.Ms.Type.CastDupIf,
-					() => Terminal<TPk, TPKh>.NewDupIf(ast.Ms),
-					ast.CompExtData.CastDupIf
-					),
-				new Cast<TPk, TPKh>(
-					ast.Ms.Ext.CastLikely,
-					ast.Ms.Type.CastLikely,
-					() => Terminal<TPk, TPKh>.NewOrI(Miniscript<TPk, TPKh>.FromAst(Terminal<TPk, TPKh>.False), ast.Ms),
-					ast.CompExtData.CastLikely
-					),
-				new Cast<TPk, TPKh>(
-					ast.Ms.Ext.CastUnLikely,
-					ast.Ms.Type.CastUnLikely,
-					() => Terminal<TPk, TPKh>.NewOrI(Miniscript<TPk, TPKh>.FromAst(Terminal<TPk, TPKh>.False), ast.Ms),
-					ast.CompExtData.CastUnLikely
-					),
-				new Cast<TPk, TPKh>(
-					ast.Ms.Ext.CastVerify,
-					ast.Ms.Type.CastVerify,
-					() => Terminal<TPk, TPKh>.NewVerify(ast.Ms),
-					ast.CompExtData.CastVerify
-					),
-				new Cast<TPk, TPKh>(
-					ast.Ms.Ext.CastNonZero,
-					ast.Ms.Type.CastNonZero,
-					() => Terminal<TPk, TPKh>.NewNonZero(ast.Ms),
-					ast.CompExtData.CastNonZero
-					),
-				new Cast<TPk, TPKh>(
-					ast.Ms.Ext.CastTrue,
-					ast.Ms.Type.CastTrue,
-					() => Terminal<TPk, TPKh>.NewAndV(ast.Ms, Miniscript<TPk, TPKh>.FromAst(Terminal<TPk, TPKh>.True)),
-					ast.CompExtData.CastTrue
-					),
-				new Cast<TPk, TPKh>(
-					ast.Ms.Ext.CastSwap,
-					ast.Ms.Type.CastSwap,
-					() => Terminal<TPk, TPKh>.NewSwap(ast.Ms),
-					ast.CompExtData.CastSwap
-					),
-				new Cast<TPk, TPKh>(
-					ast.Ms.Ext.CastAlt,
-					ast.Ms.Type.CastAlt,
-					() => Terminal<TPk, TPKh>.NewAlt(ast.Ms),
-					ast.CompExtData.CastAlt
-					),
-				new Cast<TPk, TPKh>(
-					ast.Ms.Ext.CastZeroNotEqual,
-					ast.Ms.Type.CastZeroNotEqual,
-					() => Terminal<TPk, TPKh>.NewZeroNotEqual(ast.Ms),
-					ast.CompExtData.CastZeroNotEqual
-					),
-			};
+				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>.True)),
+							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>
@@ -498,15 +603,10 @@ private static void InsertElemClosure(
 
 			while (castStack.Count != 0)
 			{
-				var casts = Cast<TPk, TPKh>.GetAllCasts(castStack.Dequeue());
-				foreach (var c in casts)
+				var casts = castStack.Dequeue().GetAllCasts();
+				foreach (var newExt in casts)
 				{
-					AstElemExt<TPk, TPKh> newExt = null;
-					try
-					{
-						newExt = c.InvokeCast();
-					} catch (FragmentPropertyException ) { }
-					if (!(newExt is null) && InsertElem(map, newExt, satProb, dissatProb))
+					if (InsertElem(map, newExt, satProb, dissatProb))
 						castStack.Enqueue(newExt);
 				}
 			}
@@ -545,16 +645,9 @@ private static void InsertBestWrapped(
 			{
 				foreach (var x in BestCompilations(policyCache, policy, satProb, null).Values)
 				{
-					var casts = Cast<TPk, TPKh>.GetAllCasts(x);
-					foreach (var c in casts) {
-						try
-						{
-							var newExt = c.InvokeCast();
-							InsertElemClosure(map, newExt, satProb, dissatProb);
-						}
-						catch (FragmentPropertyException _)
-						{
-						}
+					var casts = x.GetAllCasts();
+					foreach (var newExt in casts) {
+						InsertElemClosure(map, newExt, satProb, dissatProb);
 					}
 				}
 			}
@@ -764,8 +857,10 @@ private static IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> BestCompilatio
 					}
 
 					var astResult = Terminal<TPk, TPKh>.NewThresh(pol.Item1, subAst);
+					new CompilerExtData().TryThreshold((int) pol.Item1, n, index => subExtData[index],
+						out var newThresh, new List<FragmentPropertyException>());
 					var astExtResult = new AstElemExt<TPk, TPKh>(
-						new CompilerExtData().Threshold((int)pol.Item1, n, index => subExtData[index]),
+							newThresh,
 							Miniscript<TPk, TPKh>.FromAst(astResult));
 					insertWrap(astExtResult);
 					var keyVec =
diff --git a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
index fcdc140229..94e3167cb7 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 
 namespace NBitcoin.Scripting.Miniscript.Types
@@ -72,104 +73,228 @@ public override Correctness FromHash()
 		public override Correctness FromTime(uint time)
 			=> new Correctness(Base.B, Input.Zero, false, false);
 
-		public override Correctness CastAlt()
-			=> new Correctness(
-				(Base == Base.B ? Base.W : throw FragmentPropertyException.ChildBase1(Base)),
-				Input.Any,
-				DisSatisfiable,
-				Unit
-		);
+		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;
+			}
 
-		public override Correctness CastSwap() =>
-			new Correctness(
-				(Base == Base.B ? Base.W : throw FragmentPropertyException.ChildBase1(Base)),
-				(Input == Input.One || Input == Input.OneNonZero ? Input.Any : throw FragmentPropertyException.ChildBase1(Base)),
+			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 Correctness CastCheck() =>
-			new Correctness(
-				(Base == Base.K ? Base.B : throw FragmentPropertyException.ChildBase1(Base)),
+		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 Correctness CastDupIf() =>
-			new Correctness(
-				(Base == Base.V ? Base.B : throw FragmentPropertyException.ChildBase1(Base)),
-				(Input == Input.Zero ? Input.OneNonZero : throw FragmentPropertyException.NonZeroDupIf()),
+		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 Correctness CastVerify() =>
-			new Correctness(
-				(Base == Base.B ? Base.V : throw FragmentPropertyException.ChildBase1(Base)),
+		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
-				);
+				false, false
+			);
+			return true;
+		}
 
-		public override Correctness CastNonZero()
+		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)
-				throw FragmentPropertyException.NonZeroZero();
-			return new Correctness(
-				(Base == Base.B ? Base.B : throw FragmentPropertyException.ChildBase1(Base)),
+			{
+				error.Add(FragmentPropertyException.NonZeroZero());
+				return false;
+			}
+
+			result =
+				new Correctness(
+					Base.B,
 				Input,
 				true,
 				Unit
 				);
+			return true;
 		}
 
-		public override Correctness CastZeroNotEqual() =>
-			new Correctness(
-				(Base == Base.B ? Base.B : throw FragmentPropertyException.ChildBase1(Base)),
+		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 Correctness CastTrue() =>
+		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 == Base.V ? Base.B : throw FragmentPropertyException.ChildBase1(Base)),
+				Base.B,
 				Input,
 				false,
 				true
 			);
+			return true;
+		}
 
-		public override Correctness CastOrIFalse() =>
+		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 == Base.B ? Base.B : throw FragmentPropertyException.ChildBase1(Base)),
+				Base.B,
 				(Input == Input.Zero ? Input.One : Input.Any),
 				true,
 				Unit
-				);
-
-		public override Correctness AndB(Correctness l, Correctness r) =>
-			new Correctness(
-				((l.Base == Base.B && r.Base == Base.W) ? Base.B : throw FragmentPropertyException.ChildBase2(l.Base, r.Base) ),
-
-				(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),
+			);
+			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 Correctness AndV(Correctness l, Correctness r)
+		public override bool TryAndV(Correctness l, Correctness r, out Correctness result, List<FragmentPropertyException> error)
 		{
-			return new Correctness(
+			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 : throw FragmentPropertyException.ChildBase2(l.Base, r.Base),
-
+				(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 :
@@ -182,16 +307,32 @@ public override Correctness AndV(Correctness l, Correctness r)
 				false,
 				r.Unit
 				);
+			return true;
 		}
 
-		public override Correctness OrB(Correctness l, Correctness r)
+		public override bool TryOrB(Correctness l, Correctness r, out Correctness result, List<FragmentPropertyException> error)
 		{
+			result = null;
 			if (!l.DisSatisfiable)
-				throw FragmentPropertyException.LeftNotDissatisfiable();
+			{
+				error.Add(FragmentPropertyException.LeftNotDissatisfiable());
+				return false;
+			}
+
 			if (!r.DisSatisfiable)
-				throw FragmentPropertyException.RightNotDissatisfiable();
-			return new Correctness(
-				(l.Base == Base.B && r.Base == Base.W) ? Base.B : throw FragmentPropertyException.ChildBase2(l.Base, r.Base),
+			{
+				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) ||
@@ -201,16 +342,32 @@ public override Correctness OrB(Correctness l, Correctness r)
 				true,
 				true
 				);
+			return true;
 		}
 
-		public override Correctness OrD(Correctness l, Correctness r)
+		public override bool TryOrD(Correctness l, Correctness r, out Correctness result, List<FragmentPropertyException> error)
 		{
+			result = null;
 			if (!l.DisSatisfiable)
-				throw FragmentPropertyException.LeftNotDissatisfiable();
+			{
+				error.Add(FragmentPropertyException.LeftNotDissatisfiable());
+				return false;
+			}
+
 			if (!l.Unit)
-				throw FragmentPropertyException.LeftNotUnit();
-			return new Correctness(
-				(l.Base == Base.B) ? Base.B : throw FragmentPropertyException.ChildBase2(l.Base, r.Base),
+			{
+				error.Add(FragmentPropertyException.LeftNotUnit());
+				return false;
+			}
+
+			if (l.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 :
@@ -218,47 +375,91 @@ public override Correctness OrD(Correctness l, Correctness r)
 				r.DisSatisfiable,
 				r.Unit
 				);
+			return true;
 		}
 
-		public override Correctness OrC(Correctness l, Correctness r)
+		public override bool TryOrC(Correctness l, Correctness r, out Correctness result, List<FragmentPropertyException> error)
 		{
+			result = null;
 			if (!l.DisSatisfiable)
-				throw FragmentPropertyException.LeftNotDissatisfiable();
+			{
+				error.Add(FragmentPropertyException.LeftNotDissatisfiable());
+				return false;
+			}
+
 			if (!l.Unit)
-				throw FragmentPropertyException.LeftNotUnit();
+			{
+				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;
+			}
 
-			return
+			result =
 				new Correctness(
-					(l.Base == Miniscript.Base.B && r.Base == Miniscript.Base.V)
-						? Miniscript.Base.V
-						: throw FragmentPropertyException.ChildBase2(l.Base, r.Base),
+					Base.V,
 					Miniscript.Input.Any,
 					false,
 					false
 				);
+			return true;
 		}
 
-		public override Correctness OrI(Correctness l, Correctness r) =>
-			new Correctness(
+		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 : throw FragmentPropertyException.ChildBase2(l.Base, r.Base),
-				(l.Input == Miniscript.Input.Zero && r.Input == Miniscript.Input.Zero) ? Miniscript.Input.One : Miniscript.Input.Any,
+				(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 Correctness AndOr(Correctness a, Correctness b, Correctness c)
+		public override bool TryAndOr(Correctness a, Correctness b, Correctness c, out Correctness result, List<FragmentPropertyException> error)
 		{
+			result = null;
 			if (!a.DisSatisfiable)
-				throw FragmentPropertyException.LeftNotDissatisfiable();
+			{
+				error.Add(FragmentPropertyException.LeftNotDissatisfiable());
+				return false;
+			}
+
 			if (!a.Unit)
-				throw FragmentPropertyException.LeftNotUnit();
-			return new Correctness(
+			{
+				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 :
-					throw FragmentPropertyException.ChildBase3(a.Base, b.Base, c.Base),
+				(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) ||
@@ -271,10 +472,12 @@ public override Correctness AndOr(Correctness a, Correctness b, Correctness c)
 				c.DisSatisfiable,
 				b.Unit && c.Unit
 				);
+			return true;
 		}
 
-		public override Correctness Threshold(int k, int n, Func<int, Correctness> subCk)
+		public override bool TryThreshold(int k, int n, Func<int, Correctness> subCk, out Correctness result, List<FragmentPropertyException> error)
 		{
+			result = null;
 			var isN = k == n;
 			for (int i = 0; i < n; i++)
 			{
@@ -283,24 +486,39 @@ public override Correctness Threshold(int k, int n, Func<int, Correctness> subCk
 				{
 					isN &= subType.Input == Input.OneNonZero || subType.Input == Input.AnyNonZero;
 					if (subType.Base != Base.B)
-						throw FragmentPropertyException.ThresholdBase(0U, subType.Base);
+					{
+						error.Add(FragmentPropertyException.ThresholdBase(0U, subType.Base));
+						return false;
+					}
 				}
 				else
 				{
 					if (subType.Base != Miniscript.Base.W)
-						throw FragmentPropertyException.ThresholdBase((uint)n, subType.Base);
+					{
+						error.Add(FragmentPropertyException.ThresholdBase((uint) n, subType.Base));
+						return false;
+					}
 				}
+
 				if (!subType.Unit)
-					throw FragmentPropertyException.ThresholdNonUnit((uint)n);
+				{
+					error.Add(FragmentPropertyException.ThresholdNonUnit((uint) n));
+					return false;
+				}
+
 				if (!subType.DisSatisfiable)
-					throw FragmentPropertyException.ThresholdDissat((uint)n);
+				{
+					error.Add(FragmentPropertyException.ThresholdDissat((uint) n));
+					return false;
+				}
 			}
-			return new Correctness(
+			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
index ac3c8e264c..b01569c926 100644
--- a/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
@@ -168,17 +168,24 @@ public override ExtData FromTime(uint time) =>
 				1,
 				null
 				);
-		public override ExtData CastAlt() =>
-			new ExtData(
-				LegacySafe,
-				PkCost + 2,
-				false,
-				OpsCountStatic + 2,
-				OpsCountSat + 2,
-				OpsCountNSat + 2
+
+		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 ExtData CastSwap() =>
+		public override bool TryCastSwap(out ExtData result, List<FragmentPropertyException> error)
+		{
+			result =
 			new ExtData(
 				LegacySafe,
 				PkCost + 1,
@@ -186,9 +193,12 @@ public override ExtData CastSwap() =>
 				OpsCountStatic + 1,
 				OpsCountSat + 1,
 				OpsCountNSat + 1
-				);
+			);
+			return true;
+		}
 
-		public override ExtData CastCheck() =>
+		public override bool TryCastCheck(out ExtData result, List<FragmentPropertyException> error) {
+			result =
 			new ExtData(
 				LegacySafe,
 				PkCost + 1,
@@ -197,8 +207,11 @@ public override ExtData CastCheck() =>
 				OpsCountSat + 1,
 				OpsCountNSat + 1
 				);
+			return true;
+		}
 
-		public override ExtData CastDupIf() =>
+		public override bool TryCastDupIf(out ExtData result, List<FragmentPropertyException> error) {
+			result =
 			new ExtData(
 				LegacySafe.SegwitOnly,
 				PkCost + 3,
@@ -207,11 +220,14 @@ public override ExtData CastDupIf() =>
 				OpsCountSat + 3,
 				OpsCountStatic + 3
 				);
+			return true;
+		}
 
-		public override ExtData CastVerify()
+		public override bool TryCastVerify(out ExtData result, List<FragmentPropertyException> error)
 		{
 			var verifyCost = this.HasVerifyForm ? 0UL : 1UL;
-			return new ExtData(
+			result =
+			new ExtData(
 				LegacySafe,
 				PkCost + verifyCost,
 				false,
@@ -219,19 +235,25 @@ public override ExtData CastVerify()
 				OpsCountSat + verifyCost,
 				null
 				);
+			return true;
 		}
 
-		public override ExtData CastNonZero() =>
-			new ExtData(
-				LegacySafe,
-				PkCost + 4UL,
-				false,
-				OpsCountStatic + 4,
-				OpsCountSat + 4UL,
-				OpsCountStatic + 4
+		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 ExtData CastZeroNotEqual() =>
+		public override bool TryCastZeroNotEqual(out ExtData result, List<FragmentPropertyException> error) {
+			result =
 			new ExtData(
 				LegacySafe,
 				PkCost + 1,
@@ -240,8 +262,11 @@ public override ExtData CastZeroNotEqual() =>
 				OpsCountSat + 1UL,
 				OpsCountNSat + 1UL
 				);
+			return true;
+		}
 
-		public override ExtData CastTrue() =>
+		public override bool TryCastTrue(out ExtData result, List<FragmentPropertyException> error) {
+			result =
 			new ExtData(
 				LegacySafe,
 				PkCost + 1,
@@ -250,13 +275,16 @@ public override ExtData CastTrue() =>
 				OpsCountSat,
 				null
 				);
+			return true;
+		}
 
-		public override ExtData CastOrIFalse()
+		public override bool TryCastOrIFalse(out ExtData result, List<FragmentPropertyException> error)
 		{
 			throw new Exception("Unreachable!");
 		}
 
-		public override ExtData CastUnLikely() =>
+		public override bool TryCastUnLikely(out ExtData result, List<FragmentPropertyException> error) {
+			result =
 			new ExtData(
 				LegacySafe,
 				PkCost + 4,
@@ -265,8 +293,11 @@ public override ExtData CastUnLikely() =>
 				OpsCountSat + 3,
 				OpsCountNSat + 3
 				);
+			return true;
+		}
 
-		public override ExtData CastLikely() =>
+		public override bool TryCastLikely(out ExtData result, List<FragmentPropertyException> error) {
+			result =
 			new ExtData(
 				LegacySafe,
 				PkCost + 4,
@@ -275,30 +306,41 @@ public override ExtData CastLikely() =>
 				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 ExtData AndB(ExtData l, ExtData r) =>
-			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
+		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 ExtData AndV(ExtData l, ExtData r) =>
-			new ExtData(
+		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 ExtData OrB(ExtData left, ExtData right) =>
+		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,
@@ -306,13 +348,16 @@ public override ExtData OrB(ExtData left, ExtData right) =>
 				left.OpsCountStatic + right.OpsCountStatic + 1,
 				left.OpsCountSat + right.OpsCountSat + 1,
 				left.OpsCountNSat + right.OpsCountNSat + 1
-				);
+			);
+			return true;
+		}
 
-		public override ExtData OrD(ExtData left, ExtData right)
+		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;
-			return new ExtData(
+			result =
+			new ExtData(
 				LegacySafe.SegwitOnly,
 				left.PkCost + right.PkCost + 3,
 				false,
@@ -320,14 +365,15 @@ public override ExtData OrD(ExtData left, ExtData right)
 				Nullable.Compare(opsCountSat1, opsCountSat2) > 0 ? opsCountSat1 : opsCountSat2,
 				left.OpsCountSat + right.OpsCountNSat + 3
 			);
+			return true;
 		}
 
-		public override ExtData OrC(ExtData left, ExtData right)
+		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;
 
-			return
+			result =
 			new ExtData(
 				LegacySafe2(left.LegacySafe, right.LegacySafe),
 				left.PkCost + right.PkCost + 2,
@@ -336,9 +382,10 @@ public override ExtData OrC(ExtData left, ExtData right)
 				Nullable.Compare(opsCountSat1, opsCountSat2) > 0 ? opsCountSat1 : opsCountSat2,
 					null
 			);
+			return true;
 		}
 
-		public override ExtData OrI(ExtData left, ExtData right)
+		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;
@@ -350,7 +397,8 @@ public override ExtData OrI(ExtData left, ExtData right)
 					: (left.OpsCountNSat.HasValue)
 						? left.OpsCountNSat + 3
 						: right.OpsCountNSat + 3;
-			return new ExtData(
+			result =
+			new ExtData(
 				LegacySafe2(left.LegacySafe, right.LegacySafe),
 				left.PkCost + right.PkCost + 3,
 				false,
@@ -358,9 +406,10 @@ public override ExtData OrI(ExtData left, ExtData right)
 				Nullable.Compare(opsCountSat1, opsCountSat2) > 0 ? opsCountSat1 : opsCountSat2,
 				opsCountNSat
 				);
+			return true;
 		}
 
-		public override ExtData AndOr(ExtData a, ExtData b, ExtData c)
+		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;
@@ -369,7 +418,7 @@ public override ExtData AndOr(ExtData a, ExtData b, ExtData c)
 
 			var opsCountNSat = c.OpsCountNSat +  b.OpsCountStatic + a.OpsCountNSat + 3;
 
-			return new ExtData(
+			result = new ExtData(
 				legacySafe,
 				a.PkCost + b.PkCost + c.PkCost + 2,
 				false,
@@ -377,9 +426,10 @@ public override ExtData AndOr(ExtData a, ExtData b, ExtData c)
 				opsCountSat,
 				opsCountNSat
 				);
+			return true;
 		}
 
-		public override ExtData Threshold(int k, int n, Func<int, ExtData> subCk)
+		public override bool TryThreshold(int k, int n, Func<int, ExtData> subCk, out ExtData result, List<FragmentPropertyException> error)
 		{
 			var pkCost = 1UL + (ulong)Utils.ScriptNumSize(k);
 			var legacySafe = LegacySafe.LegacySafe;
@@ -421,7 +471,7 @@ public override ExtData Threshold(int k, int n, Func<int, ExtData> subCk)
 				Func<ulong?, double> summer = v => v.Value;
 				sum = (ulong)opsCountSatVec.Skip(remainingSat).Sum(summer);
 			}
-			return new ExtData(
+			result = new ExtData(
 				legacySafe,
 				pkCost + (ulong)n - 1UL,
 				true,
@@ -429,6 +479,7 @@ public override ExtData Threshold(int k, int n, Func<int, ExtData> subCk)
 				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
index 0b4ec3beb9..c3772cef04 100644
--- a/NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs
@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 
 namespace NBitcoin.Scripting.Miniscript.Types
 {
@@ -101,10 +103,11 @@ public enum ErrorKind
 		/// </summary>
 		ThresholdNonUnit,
 	}
-	class FragmentPropertyException : Exception
+	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")}")
 		{
@@ -162,5 +165,12 @@ public static FragmentPropertyException ZeroTime(string fragment = null) =>
 				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
index 4542be3996..2db7b02425 100644
--- a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
@@ -1,24 +1,25 @@
 using System;
+using System.Collections.Generic;
 using NBitcoin.Scripting.Miniscript.Policy;
 
 namespace NBitcoin.Scripting.Miniscript.Types
 {
-	public abstract class IProperty<T> where T: IProperty<T>
+	internal abstract class IProperty<T> where T: IProperty<T>
 	{
 		public virtual void SanityChecks() {}
 
 		# region Casting operation
-		public abstract T CastAlt();
-		public abstract T CastSwap();
-		public abstract T CastCheck();
-		public abstract T CastDupIf();
-		public abstract T CastVerify();
-		public abstract T CastNonZero();
-		public abstract T CastZeroNotEqual();
-		public abstract T CastTrue();
-		public abstract T CastOrIFalse();
-		public virtual T CastUnLikely() => CastOrIFalse();
-		public virtual T CastLikely() => CastOrIFalse();
+		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
 
@@ -43,15 +44,17 @@ public virtual void SanityChecks() {}
 		public virtual T FromOlder(uint time) => this.FromTime(time);
 
 
-		public abstract T AndB(T l, T r);
-		public abstract T AndV(T l, T r);
-		public virtual T AndN(T l, T r) => AndOr(l, r, FromFalse());
-		public abstract T OrB(T left, T right);
-		public abstract T OrD(T left, T right);
-		public abstract T OrC(T left, T right);
-		public abstract T OrI(T left, T right);
-		public abstract T AndOr(T a, T b, T c);
-		public abstract T Threshold(int k, int n, Func<int, T> subCk);
+		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 abstract bool TryThreshold(int k, int n, Func<int, T> subCk, out T result, List<FragmentPropertyException> error);
 		#endregion
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
index 9b682a89d3..eb43c7129e 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics.Tracing;
 using NBitcoin.Scripting.Miniscript.Policy;
 
@@ -85,73 +86,115 @@ public override Malleability FromTime(uint time) =>
 		public override Malleability FromHash() =>
 			new Malleability(Dissat.Unknown, false, true);
 
-		public override Malleability CastAlt() =>
-			this;
+		public override bool TryCastAlt(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = this;
+			return true;
+		}
 
-		public override Malleability CastSwap() =>
-			this;
+		public override bool TryCastSwap(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = this;
+			return true;
+		}
 
-		public override Malleability CastCheck() =>
-			this;
+		public override bool TryCastCheck(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = this;
+			return true;
+		}
 
-		public override Malleability CastDupIf() =>
+		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 Malleability CastVerify() =>
+		public override bool TryCastVerify(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result =
 			new Malleability(
 				Dissat.None,
 				Safe,
 				NonMalleable
-				);
+			);
+			return true;
+		}
 
-		public override Malleability CastNonZero() =>
-			new Malleability(
+		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 Malleability CastZeroNotEqual() => this;
+		public override bool TryCastZeroNotEqual(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = this;
+			return true;
+		}
 
-		public override Malleability CastTrue() =>
-			new Malleability(
+		public override bool TryCastTrue(out Malleability result, List<FragmentPropertyException> error)
+		{
+			result = new Malleability(
 				Dissat == Dissat.None ? Dissat.Unique : Dissat.Unknown,
 				Safe,
 				NonMalleable
-				);
+			);
+			return true;
+		}
 
-		public override Malleability CastOrIFalse() =>
-			new Malleability(
+		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 Malleability AndB(Malleability left, Malleability right) =>
-			new Malleability(
+		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.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 Malleability AndV(Malleability left, Malleability right) =>
-			new Malleability(
+		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 Malleability OrB(Malleability left, Malleability right) =>
-			new Malleability(
+		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
@@ -159,45 +202,57 @@ public override Malleability OrB(Malleability left, Malleability right) =>
 				&& right.NonMalleable
 				&& right.Dissat == Dissat.Unique
 				&& (left.Safe || right.Safe)
-				);
+			);
+			return true;
+		}
 
-		public override Malleability OrD(Malleability left, Malleability right) =>
-			new Malleability(
+		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 Malleability OrC(Malleability left, Malleability right) =>
-			new Malleability(
+		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 Malleability OrI(Malleability left, Malleability right) =>
-			new Malleability(
+		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 :
+				(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 Malleability AndOr(Malleability a, Malleability b, Malleability c) =>
-			new Malleability(
+		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 :
+				(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
@@ -205,9 +260,11 @@ public override Malleability AndOr(Malleability a, Malleability b, Malleability
 				&& c.NonMalleable
 				&& a.Dissat == Dissat.Unique
 				&& (a.Safe || b.Safe || c.Safe)
-				);
+			);
+			return true;
+		}
 
-		public override Malleability Threshold(int k, int n, Func<int, Malleability> subCk)
+		public override bool TryThreshold(int k, int n, Func<int, Malleability> subCk, out Malleability result, List<FragmentPropertyException> error)
 		{
 			var safeCount = 0;
 			var allAreDissatUnique = true;
@@ -219,11 +276,12 @@ public override Malleability Threshold(int k, int n, Func<int, Malleability> sub
 				allAreDissatUnique &= subType.Dissat == Dissat.Unique;
 				allAreNonMalleable &= subType.NonMalleable;
 			}
-			return new Malleability(
+			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
index 686aa89157..ee2ec3cd8b 100644
--- a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using NBitcoin.Scripting.Miniscript.Policy;
 using Dissat = NBitcoin.Scripting.Miniscript.Types.Dissat;
@@ -7,7 +8,7 @@
 namespace NBitcoin.Scripting.Miniscript.Types
 {
 	[DebuggerDisplay("{" + nameof(DebugPrint) + "()}")]
-	public class MiniscriptFragmentType : IProperty<MiniscriptFragmentType>, IEquatable<MiniscriptFragmentType>
+	internal class MiniscriptFragmentType : IProperty<MiniscriptFragmentType>, IEquatable<MiniscriptFragmentType>
 	{
 		internal readonly Correctness Correctness;
 
@@ -112,115 +113,249 @@ public override MiniscriptFragmentType FromHash160()
 				new Correctness().FromHash160(),
 				new Malleability().FromHash160());
 
-		public override MiniscriptFragmentType CastAlt()
-			=>
-			new MiniscriptFragmentType(
-				Correctness.CastAlt(),
-				Malleability.CastAlt());
+		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 MiniscriptFragmentType CastSwap()
-			=> new MiniscriptFragmentType(
-				Correctness.CastSwap(),
-				Malleability.CastSwap());
+		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 MiniscriptFragmentType CastCheck()
-			=> new MiniscriptFragmentType(
-				Correctness.CastCheck(),
-				Malleability.CastCheck());
+		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 MiniscriptFragmentType CastDupIf()
-			=> new MiniscriptFragmentType(
-				Correctness.CastDupIf(),
-				Malleability.CastDupIf());
+		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 MiniscriptFragmentType CastVerify()
-			=> new MiniscriptFragmentType(
-				Correctness.CastVerify(),
-				Malleability.CastVerify());
-		public override MiniscriptFragmentType CastNonZero()
-			=>
-			new MiniscriptFragmentType(
-				Correctness.CastNonZero(),
-				Malleability.CastNonZero());
+		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 MiniscriptFragmentType CastZeroNotEqual()
-			=>
-			new MiniscriptFragmentType(
-				Correctness.CastZeroNotEqual(),
-				Malleability.CastZeroNotEqual());
+		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 MiniscriptFragmentType CastTrue()
-			=>
-			new MiniscriptFragmentType(
-				Correctness.CastTrue(),
-				Malleability.CastTrue());
 
-		public override MiniscriptFragmentType CastOrIFalse()
-			=>
-			new MiniscriptFragmentType(
-				Correctness.CastOrIFalse(),
-				Malleability.CastOrIFalse());
+		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 MiniscriptFragmentType CastUnLikely()
-			=>
-			new MiniscriptFragmentType(
-				Correctness.CastUnLikely(),
-				Malleability.CastUnLikely());
+		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 MiniscriptFragmentType CastLikely()
-			=>
-			new MiniscriptFragmentType(
-				Correctness.CastLikely(),
-				Malleability.CastLikely());
+		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 MiniscriptFragmentType AndB(MiniscriptFragmentType left, MiniscriptFragmentType right)
-			=>
-			new MiniscriptFragmentType(
-				new Correctness().AndB(left.Correctness, right.Correctness),
-				new Malleability().AndB(left.Malleability, right.Malleability));
 
-		public override MiniscriptFragmentType AndV(MiniscriptFragmentType left, MiniscriptFragmentType right)
-			=>
-			new MiniscriptFragmentType(
-				new Correctness().AndV(left.Correctness, right.Correctness),
-				new Malleability().AndV(left.Malleability, right.Malleability));
+		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 MiniscriptFragmentType OrB(MiniscriptFragmentType left, MiniscriptFragmentType right)
-			=>
-			new MiniscriptFragmentType(
-				new Correctness().OrB(left.Correctness, right.Correctness),
-				new Malleability().OrB(left.Malleability, right.Malleability));
 
-		public override MiniscriptFragmentType OrD(MiniscriptFragmentType left, MiniscriptFragmentType right)
-			=>
-			new MiniscriptFragmentType(
-				new Correctness().OrD(left.Correctness, right.Correctness),
-				new Malleability().OrD(left.Malleability, right.Malleability));
+		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 MiniscriptFragmentType OrC(MiniscriptFragmentType left, MiniscriptFragmentType right)
-			=>
-			new MiniscriptFragmentType(
-				new Correctness().OrC(left.Correctness, right.Correctness),
-				new Malleability().OrC(left.Malleability, right.Malleability));
+		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 MiniscriptFragmentType OrI(MiniscriptFragmentType left, MiniscriptFragmentType right)
-			=>
-			new MiniscriptFragmentType(
-				new Correctness().OrI(left.Correctness, right.Correctness),
-				new Malleability().OrI(left.Malleability, right.Malleability));
 
-		public override MiniscriptFragmentType AndOr(MiniscriptFragmentType a, MiniscriptFragmentType b, MiniscriptFragmentType c)
-			=>
-			new MiniscriptFragmentType(
-				new Correctness().AndOr(a.Correctness, b.Correctness, c.Correctness),
-				new Malleability().AndOr(a.Malleability, b.Malleability, c.Malleability));
+		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 MiniscriptFragmentType Threshold(int k, int n, Func<int, MiniscriptFragmentType> func)
-			=>
-				new MiniscriptFragmentType(
-					new Correctness().Threshold(k, n, i => func(i).Correctness),
-					new Malleability().Threshold(k, n , i => func(i).Malleability));
+
+		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, Func<int, MiniscriptFragmentType> func,
+			out MiniscriptFragmentType result, List<FragmentPropertyException> error)
+		{
+			result = null;
+			if (new Correctness().TryThreshold(k, n, i => func(i).Correctness, out var corr, error)
+			    && new Malleability().TryThreshold(k, n, i => func(i).Malleability, out var mall, error)
+			)
+			{
+				result = new MiniscriptFragmentType(corr, mall);
+				return true;
+			}
+			return false;
+		}
 
 
 		public override bool Equals(object obj) => Equals(obj as MiniscriptFragmentType);
diff --git a/NBitcoin/Scripting/Miniscript/Types/Property.cs b/NBitcoin/Scripting/Miniscript/Types/Property.cs
index 51adc4dd42..de78c1f7d6 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Property.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Property.cs
@@ -1,9 +1,10 @@
 using System;
+using System.Collections.Generic;
 using NBitcoin.Scripting.Miniscript.Policy;
 
 namespace NBitcoin.Scripting.Miniscript.Types
 {
-	public static class Property<T, TPk, TPKh>
+	internal static class Property<T, TPk, TPKh>
 	where T : IProperty<T>, new()
 	where TPk : class, IMiniscriptKey<TPKh>, new()
 	where TPKh : class, IMiniscriptKeyHash, new()
@@ -45,6 +46,9 @@ T GetChild(Terminal<TPk, TPKh> sub, int n)
 					return new T().FromFalse();
 			}
 
+			var errors = new List<FragmentPropertyException>();
+			T res;
+
 			switch (fragment)
 			{
 				case Terminal<TPk, TPKh>.Pk self:
@@ -87,48 +91,76 @@ T GetChild(Terminal<TPk, TPKh> sub, int n)
 				case Terminal<TPk, TPKh>.Hash160 self:
 					return new T().FromHash160();
 				case Terminal<TPk, TPKh>.Alt self:
-					return GetChild(self.Item.Node, 0).CastAlt();
+					if (GetChild(self.Item.Node, 0).TryCastAlt(out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.Swap self:
-					return GetChild(self.Item.Node, 0).CastSwap();
+					if (GetChild(self.Item.Node, 0).TryCastSwap(out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.Check self:
-					return GetChild(self.Item.Node, 0).CastCheck();
+					if (GetChild(self.Item.Node, 0).TryCastCheck(out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.DupIf self:
-					return GetChild(self.Item.Node, 0).CastDupIf();
+					if (GetChild(self.Item.Node, 0).TryCastDupIf(out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.Verify self:
-					return GetChild(self.Item.Node, 0).CastVerify();
+					if (GetChild(self.Item.Node, 0).TryCastVerify(out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.NonZero self:
-					return GetChild(self.Item.Node, 0).CastNonZero();
+					if (GetChild(self.Item.Node, 0).TryCastNonZero(out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.ZeroNotEqual self:
-					return GetChild(self.Item.Node, 0).CastZeroNotEqual();
+					if (GetChild(self.Item.Node, 0).TryCastZeroNotEqual(out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.AndB self:
 					var andBL = GetChild(self.Item1.Node, 0);
 					var andBR = GetChild(self.Item2.Node, 1);
-					return new T().AndB(andBL, andBR);
+					if (new T().TryAndB(andBL, andBR, out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.AndV self:
 					var andVL = GetChild(self.Item1.Node, 0);
 					var andVR = GetChild(self.Item2.Node, 1);
-					return new T().AndV(andVL, andVR);
+					if (new T().TryAndV(andVL, andVR, out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.OrB self:
 					var orBL = GetChild(self.Item1.Node, 0);
 					var orBR = GetChild(self.Item2.Node, 1);
-					return new T().OrB(orBL, orBR);
+					if (new T().TryOrB(orBL, orBR, out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.OrD self:
 					var orDL = GetChild(self.Item1.Node, 0);
 					var orDR = GetChild(self.Item2.Node, 1);
-					return new T().OrD(orDL, orDR);
+					if (new T().TryOrD(orDL, orDR, out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.OrC self:
 					var orCL = GetChild(self.Item1.Node, 0);
 					var orCR = GetChild(self.Item2.Node, 1);
-					return new T().OrC(orCL, orCR);
+					if (new T().TryOrC(orCL, orCR, out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.OrI self:
 					var orIL = GetChild(self.Item1.Node, 0);
 					var orIR = GetChild(self.Item2.Node, 1);
-					return new T().OrI(orIL, orIR);
+					if (new T().TryOrI(orIL, orIR, out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.AndOr self:
 					var a = GetChild(self.Item1.Node, 0);
 					var b = GetChild(self.Item2.Node, 1);
 					var c = GetChild(self.Item3.Node, 2);
-					return new T().AndOr(a, b, c);
+					if (new T().TryAndOr(a, b, c, out res, errors))
+						return res;
+					throw errors.Flatten();
 				case Terminal<TPk, TPKh>.Thresh self:
 					if (self.Item1 == 0)
 					{
@@ -139,9 +171,12 @@ T GetChild(Terminal<TPk, TPKh> sub, int n)
 					{
 						throw FragmentPropertyException.OverThreshold(fragment.ToString());
 					}
-					return
-						new T().Threshold((int)self.Item1, self.Item2.Length, (n) =>
-							GetChild(self.Item2[n].Node, (int)n));
+					if (new T().TryThreshold(
+						(int)self.Item1,
+						self.Item2.Length, (n) =>
+							GetChild(self.Item2[n].Node, (int)n), out res, errors))
+						return res;
+					throw errors.Flatten();
 			}
 			throw new Exception($"Unreachable! {fragment}");;
 		}

From 4b066ed3c1abf9d0c8e9c8e47c2ee77dc8269a32 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Fri, 15 Nov 2019 14:04:26 +0900
Subject: [PATCH 33/50] Update compiler tests

---
 NBitcoin.Tests/MiniscriptTests.cs             |  3 +-
 .../PropertyTest/MiniscriptPropertyTests.cs   |  5 +-
 NBitcoin/Scripting/Miniscript/ILiftable.cs    | 48 +++++++++----------
 .../Scripting/Miniscript/Policy/Compiler.cs   |  2 +-
 4 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 4f9645bffc..085e17dc3a 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -264,6 +264,7 @@ private void PolicyCompileLiftCheck(string s)
 		{
 			var policy = ConcretePolicy<PubKey, uint160>.Parse(s);
 			var ms = policy.Compile();
+			Console.WriteLine($"Compilation result was {ms}");
 			Assert.Equal(policy.Lift(), ms.Lift());
 		}
 
@@ -275,7 +276,7 @@ public void CompilerUnitTest()
 			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck("older(1)"));
 			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck("sha256(1111111111111111111111111111111111111111111111111111111111111111)"));
 			PolicyCompileLiftCheck($"and(pk({PubKeys[0]}),pk({PubKeys[1]}))");
-			// PolicyCompileLiftCheck($"or(pk({PubKeys[0]}),pk({PubKeys[1]}))");
+			PolicyCompileLiftCheck($"or(pk({PubKeys[0]}),pk({PubKeys[1]}))");
 			// PolicyCompileLiftCheck($"thresh(2,pk({PubKeys[0]}),pk({PubKeys[1]}),pk({PubKeys[2]}))");
 		}
 	}
diff --git a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
index 1e6f5591c7..c1a9845a31 100644
--- a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
+++ b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
@@ -27,17 +27,16 @@ public void ShouldBidirectionallyConvertConcretePolicyToString(ConcretePolicy<Pu
 			Assert.Equal(p.GetHashCode(), c.GetHashCode());
 		}
 
-		[Property(MaxTest = 12)]
+		[Property(MaxTest = 100)]
 		[Trait("UnitTest", "UnitTest")]
 		public void ShouldCompileConcretePolicy(ConcretePolicy<PubKey, uint160> p)
 		{
 			var t = p.IsSafeNonMalleable();
 			var isSafe = t.Item1;
 			var IsNonMalleable = t.Item2;
-				Console.WriteLine($"Compiling {p}");
 			if (isSafe && IsNonMalleable)
 			{
-				Console.WriteLine($"it is safe and non malleable");
+				Console.WriteLine($"Compiling {p}");
 				var ms = p.Compile();
 				Console.WriteLine($"Compiled {ms}");
 			}
diff --git a/NBitcoin/Scripting/Miniscript/ILiftable.cs b/NBitcoin/Scripting/Miniscript/ILiftable.cs
index 697a3bdeca..ed61efff10 100644
--- a/NBitcoin/Scripting/Miniscript/ILiftable.cs
+++ b/NBitcoin/Scripting/Miniscript/ILiftable.cs
@@ -34,43 +34,43 @@ public AbstractPolicy<TPk, TPKh> Lift()
 
 			switch (this)
 			{
-				case Pk self: return AbstractPolicy<TPk, TPKh>.NewKeyHash(self.Item.ToPubKeyHash());
-				case PkH self: return AbstractPolicy<TPk, TPKh>.NewKeyHash(self.Item);
-				case After self: return AbstractPolicy<TPk, TPKh>.NewAfter(self.Item);
-				case Older self: return AbstractPolicy<TPk, TPKh>.NewOlder(self.Item);
-				case Sha256 self: return AbstractPolicy<TPk, TPKh>.NewSha256(self.Item);
-				case Hash256 self: return AbstractPolicy<TPk, TPKh>.NewHash256(self.Item);
-				case Ripemd160 self: return AbstractPolicy<TPk, TPKh>.NewRipemd160(self.Item);
-				case Hash160 self: return AbstractPolicy<TPk, TPKh>.NewHash160(self.Item);
-				case Alt self: return self.Item.Node.Lift();
-				case Check self: return self.Item.Node.Lift();
-				case DupIf self: return self.Item.Node.Lift();
-				case Verify self: return self.Item.Node.Lift();
-				case NonZero self: return self.Item.Node.Lift();
-				case ZeroNotEqual self: return self.Item.Node.Lift();
+				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 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()});
+					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()});
+					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()});
-					return AbstractPolicy<TPk, TPKh>.NewOr(new List<AbstractPolicy<TPk, TPKh>>() {inner, self.Item2.Node.Lift()});
+					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() });
+					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() });
+					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() });
+					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() });
+					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());
+					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!");
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index d881af100b..bb72b5e87e 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -244,7 +244,7 @@ public override bool TryOrC(CompilerExtData left, CompilerExtData right, out Com
 			var rProb = right.BranchProb.Value; // and for right branch.
 			result = new CompilerExtData(
 				null,
-				lProb * (left.SatisfyCost + right.DissatCost.Value) +
+				lProb * (left.SatisfyCost) +
 				rProb * (right.SatisfyCost + left.DissatCost.Value),
 				null
 			);

From 3f35aae4c71dae7714d704236bb60196492c7069 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Fri, 15 Nov 2019 14:23:34 +0900
Subject: [PATCH 34/50] prepare ToString for AbstractPolicy

---
 NBitcoin.Tests/MiniscriptTests.cs             |  2 +-
 .../Miniscript/Policy/AbstractPolicy.cs       | 63 +++++++++++++++++++
 2 files changed, 64 insertions(+), 1 deletion(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 085e17dc3a..c062174fa5 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -264,8 +264,8 @@ private void PolicyCompileLiftCheck(string s)
 		{
 			var policy = ConcretePolicy<PubKey, uint160>.Parse(s);
 			var ms = policy.Compile();
-			Console.WriteLine($"Compilation result was {ms}");
 			Assert.Equal(policy.Lift(), ms.Lift());
+			Assert.Equal(policy.Lift().GetHashCode(), ms.Lift().GetHashCode());
 		}
 
 		[Fact]
diff --git a/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
index a154422062..707ee41e4e 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Text;
 using System.Collections.Generic;
 using System.Linq;
 using NBitcoin.BouncyCastle.Asn1;
@@ -326,5 +327,67 @@ public AbstractPolicy<TPk, TPKh> Normalize()
 
 			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!");
+		}
 	}
 }

From 4e1e59da167468c20752a50cdb12d9d7e04195f8 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Fri, 15 Nov 2019 18:02:41 +0900
Subject: [PATCH 35/50] Fix more bugs in compiler

---
 NBitcoin.Tests/MiniscriptTests.cs             |  2 +-
 .../PropertyTest/MiniscriptPropertyTests.cs   |  2 +-
 NBitcoin/Scripting/Miniscript/ILiftable.cs    |  4 +-
 .../Miniscript/Policy/AbstractPolicy.cs       | 62 +++++++++++++++----
 .../Scripting/Miniscript/Policy/Compiler.cs   |  7 ++-
 .../Types/FragmentPropertyException.cs        |  2 +-
 6 files changed, 59 insertions(+), 20 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index c062174fa5..917e56c09d 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -277,7 +277,7 @@ public void CompilerUnitTest()
 			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck("sha256(1111111111111111111111111111111111111111111111111111111111111111)"));
 			PolicyCompileLiftCheck($"and(pk({PubKeys[0]}),pk({PubKeys[1]}))");
 			PolicyCompileLiftCheck($"or(pk({PubKeys[0]}),pk({PubKeys[1]}))");
-			// PolicyCompileLiftCheck($"thresh(2,pk({PubKeys[0]}),pk({PubKeys[1]}),pk({PubKeys[2]}))");
+			PolicyCompileLiftCheck($"thresh(2,pk({PubKeys[0]}),pk({PubKeys[1]}),pk({PubKeys[2]}))");
 		}
 	}
 }
diff --git a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
index c1a9845a31..c366492d62 100644
--- a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
+++ b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
@@ -27,7 +27,7 @@ public void ShouldBidirectionallyConvertConcretePolicyToString(ConcretePolicy<Pu
 			Assert.Equal(p.GetHashCode(), c.GetHashCode());
 		}
 
-		[Property(MaxTest = 100)]
+		[Property(MaxTest = 100, Skip="For now")]
 		[Trait("UnitTest", "UnitTest")]
 		public void ShouldCompileConcretePolicy(ConcretePolicy<PubKey, uint160> p)
 		{
diff --git a/NBitcoin/Scripting/Miniscript/ILiftable.cs b/NBitcoin/Scripting/Miniscript/ILiftable.cs
index ed61efff10..3c65ffb124 100644
--- a/NBitcoin/Scripting/Miniscript/ILiftable.cs
+++ b/NBitcoin/Scripting/Miniscript/ILiftable.cs
@@ -6,8 +6,8 @@
 namespace NBitcoin.Scripting.Miniscript
 {
 	public interface ILiftable<TPk, TPKh>
-		where TPk : IMiniscriptKey<TPKh>
-		where TPKh : IMiniscriptKeyHash
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		AbstractPolicy<TPk, TPKh> Lift();
 	}
diff --git a/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
index 707ee41e4e..2cf4dc49c5 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
@@ -3,14 +3,14 @@
 using System.Collections.Generic;
 using System.Linq;
 using NBitcoin.BouncyCastle.Asn1;
-using NBitcoin.BouncyCastle.Math.EC.Multiplier;
-using NBitcoin.RPC;
+using NBitcoin.Scripting.Parser;
+
 
 namespace NBitcoin.Scripting.Miniscript.Policy
 {
 	public class AbstractPolicy<TPk, TPKh> : IEquatable<AbstractPolicy<TPk, TPKh>>
-		where TPKh : IMiniscriptKeyHash
-		where TPk : IMiniscriptKey<TPKh>
+		where TPk : class, IMiniscriptKey<TPKh>, new()
+		where TPKh : class, IMiniscriptKeyHash, new()
 	{
 		#region Subtype definitions
 		internal static class Tags
@@ -145,9 +145,9 @@ public Threshold(uint item1, List<AbstractPolicy<TPk, TPKh>> item2) : base (Tags
 		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(List<AbstractPolicy<TPk, TPKh>> item) => new And(item);
-		public static AbstractPolicy<TPk, TPKh> NewOr(List<AbstractPolicy<TPk, TPKh>> item) => new Or(item);
-		public static AbstractPolicy<TPk, TPKh> NewThreshold(uint item1, List<AbstractPolicy<TPk, TPKh>> item2) => new Threshold(item1, item2);
+		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
 
@@ -264,12 +264,50 @@ public static AbstractPolicy<TPk, TPKh> FromTree(Tree top)
 			var n = top.Name;
 			var l = top.Args.Count;
 			if (n == "UNSATISFIABLE" && l == 0)
-				return AbstractPolicy<TPk, TPKh>.UnSatisfiable;
+				return UnSatisfiable;
 			if (n == "TRIVIAL" && l == 0)
-				return AbstractPolicy<TPk, TPKh>.Trivial;
-			//if (n == "pkh" && l == 1)
-				// return AbstractPolicy<TPk, TPKh>.KeyHash;
-			throw new NotImplementedException();
+				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>
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index bb72b5e87e..fb2331f734 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -844,9 +844,9 @@ private static IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> BestCompilatio
 						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);
 					}
+					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)
@@ -1061,7 +1061,8 @@ private static AstElemExt<TPk, TPKh> BestW(
 			var result =
 				BestCompilations(policyCache, policy, satProb, dissatProb)
 					.Where(kv =>
-						kv.Key.Type.Correctness.Unit
+						kv.Key.Type.Correctness.Base == Base.W
+						&& kv.Key.Type.Correctness.Unit
 						&& kv.Value.Ms.Type.Malleability.Dissat == Dissat.Unique
 						&& kv.Key.DissatProb == dissatProb
 					);
diff --git a/NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs b/NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs
index c3772cef04..fe479c881b 100644
--- a/NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/FragmentPropertyException.cs
@@ -144,7 +144,7 @@ public static FragmentPropertyException  RightNotDissatisfiable(string 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 (first must be `B` and rest must be `W`.)", fragment);
+				$"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);

From 20f4536e77b65ea84f1ff99e7668997ba5561536 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Fri, 15 Nov 2019 23:49:40 +0900
Subject: [PATCH 36/50] Avoid throwing FragmentPropertyException for internal
 flow-handling

---
 NBitcoin.Tests/MiniscriptTests.cs             |  35 +++-
 NBitcoin/Scripting/Miniscript/AstElem.cs      |  95 ++++-----
 NBitcoin/Scripting/Miniscript/Miniscript.cs   |  34 ++--
 .../Scripting/Miniscript/Policy/Compiler.cs   |  76 ++++---
 .../Scripting/Miniscript/Types/Correctness.cs |   5 +-
 .../Scripting/Miniscript/Types/ExtData.cs     |   6 +-
 .../Scripting/Miniscript/Types/IProperty.cs   |   4 +-
 .../Miniscript/Types/Malleability.cs          |   6 +-
 .../Types/MiniscriptFragmentType.cs           |  28 ++-
 .../Scripting/Miniscript/Types/Property.cs    | 190 +++++++++---------
 10 files changed, 267 insertions(+), 212 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 917e56c09d..e7333b4a09 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using NBitcoin.DataEncoders;
 using NBitcoin.Scripting.Miniscript;
@@ -206,14 +207,6 @@ public void MiniscriptAttributesTest(
 			}
 		}
 
-		[Fact]
-		[Trait("UnitTest", "UnitTest")]
-		public void TerminalUnitTest()
-		{
-			var t1 = Terminal<PubKey, uint160>.NewFalse();
-			Property<MiniscriptFragmentType, PubKey, uint160>.TypeCheck(t1);
-			Property<ExtData, PubKey, uint160>.TypeCheck(t1);
-		}
 
 		[Fact]
 		[Trait("UnitTest", "UnitTest")]
@@ -272,12 +265,38 @@ private void PolicyCompileLiftCheck(string s)
 		[Trait("UnitTest", "UnitTest")]
 		public void CompilerUnitTest()
 		{
+			// 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)))"));
+
+			// successful case
 			PolicyCompileLiftCheck($"and(pk({PubKeys[0]}),pk({PubKeys[1]}))");
 			PolicyCompileLiftCheck($"or(pk({PubKeys[0]}),pk({PubKeys[1]}))");
 			PolicyCompileLiftCheck($"thresh(2,pk({PubKeys[0]}),pk({PubKeys[1]}),pk({PubKeys[2]}))");
+			PolicyCompileLiftCheck($"or(1@and(pk({PubKeys[0]}),pk({PubKeys[1]})),127@pk({PubKeys[2]}))");
+		}
+
+		[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());
+			*/
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index c4e30522b7..9b513577c5 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -1267,10 +1267,11 @@ public string ToDebugString() =>
 
 		private StringBuilder ToDebugStringCore(StringBuilder sb)
 		{
+			var errors = new List<FragmentPropertyException>();
 			sb.Append("[");
-			try
+			if (Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(this, out var typeMap,
+				errors))
 			{
-				var typeMap = Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(this);
 				sb.Append(typeMap.Correctness.Base);
 				sb.Append(typeMap.Correctness.Input.DebugPrint());
 				if (typeMap.Correctness.DisSatisfiable)
@@ -1283,9 +1284,9 @@ private StringBuilder ToDebugStringCore(StringBuilder sb)
 				if (typeMap.Malleability.NonMalleable)
 					sb.Append('m');
 			}
-			catch (FragmentPropertyException ex)
+			else
 			{
-				sb.Append($"TYPECHECK FAILED {ex}");
+				sb.Append($"TYPECHECK FAILED {errors.Flatten()}");
 			}
 			sb.Append("]");
 
@@ -1531,56 +1532,46 @@ internal static Terminal<TPk, TPKh> FromTree(Tree top)
 			if (unwrapped is null)
 				throw new ParsingException($"{top.Name}({top.Args.Count} args) while parsing Miniscript");
 
-			foreach (var ch in fragWrap.ToCharArray().Reverse())
+			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)
 			{
-				switch (ch)
-				{
-					case 'a':
-						unwrapped = NewAlt(Miniscript<TPk, TPKh>.FromAst(unwrapped));
-						break;
-					case 's':
-						unwrapped = NewSwap(Miniscript<TPk, TPKh>.FromAst(unwrapped));
-						break;
-					case 'c':
-						unwrapped = NewCheck(Miniscript<TPk, TPKh>.FromAst(unwrapped));
-						break;
-					case 'd':
-						unwrapped = NewDupIf(Miniscript<TPk, TPKh>.FromAst(unwrapped));
-						break;
-					case 'v':
-						unwrapped = NewVerify(Miniscript<TPk, TPKh>.FromAst(unwrapped));
-						break;
-					case 'j':
-						unwrapped = NewNonZero(Miniscript<TPk, TPKh>.FromAst(unwrapped));
-						break;
-					case 'n':
-						unwrapped = NewZeroNotEqual(Miniscript<TPk, TPKh>.FromAst(unwrapped));
-						break;
-					case 't':
-						unwrapped = NewAndV(
-							Miniscript<TPk, TPKh>.FromAst(unwrapped),
-							Miniscript<TPk, TPKh>.FromAst(NewTrue())
-							);
-						break;
-					case 'u':
-						unwrapped = NewOrI(
-							Miniscript<TPk, TPKh>.FromAst(unwrapped),
-							Miniscript<TPk, TPKh>.FromAst(NewFalse())
-							);
-						break;
-					case 'l':
-						if (unwrapped == False)
-							throw new ParsingException($"Encountered l:o which is syntactically equal to `u:o` except stupid");
-						unwrapped = NewOrI(
-							Miniscript<TPk, TPKh>.FromAst(NewFalse()),
-							Miniscript<TPk, TPKh>.FromAst(unwrapped)
-							);
-						break;
-					default: throw new ParsingException($"Unknown wrapper {ch}");
-				}
+				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}");
 			}
-
-			return unwrapped;
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index b5ef85e683..d2b600c14e 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using NBitcoin.Scripting.Miniscript.Types;
 using NBitcoin.Scripting.Parser;
@@ -26,35 +27,30 @@ internal Miniscript(MiniscriptFragmentType type, Terminal<TPk, TPKh> node, ExtDa
 			Ext = ext;
 		}
 
-		public static Miniscript<TPk, TPKh> FromAst(Terminal<TPk, TPKh> t)
+		internal static Miniscript<TPk, TPKh> FromAst(Terminal<TPk, TPKh> t)
 		{
-			return
-				new Miniscript<TPk, TPKh>(
-					Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(t),
-					t,
-					Property<ExtData, TPk, TPKh>.TypeCheck(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();
 		}
 
-		public static Miniscript<TPk, TPKh> FromTree(Tree t)
+		internal static Miniscript<TPk, TPKh> FromTree(Tree t)
 		{
 			var inner = Terminal<TPk, TPKh>.FromTree(t);
-			return new Miniscript<TPk, TPKh>(
-				Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(inner),
-				inner,
-				Property<ExtData, TPk, TPKh>.TypeCheck(inner)
-				);
+			return FromAst(inner);
 		}
 		public static Miniscript<TPk, TPKh> Parse(string str)
 		{
 			try
 			{
-				var inner = Terminal<TPk, TPKh>.FromTree(Tree.Parse(str));
-				var ms = new Miniscript<TPk, TPKh>(
-					Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(inner),
-					inner,
-					Property<ExtData, TPk, TPKh>.TypeCheck(inner)
-					);
+				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;
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index fb2331f734..ee68942fca 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -285,14 +285,16 @@ public override bool TryAndN(CompilerExtData l, CompilerExtData r, out CompilerE
 			return true;
 		}
 
-		public override bool TryThreshold(int k, int n, Func<int, CompilerExtData> subCk, out CompilerExtData result, List<FragmentPropertyException> error)
+		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++)
 			{
-				var sub = subCk(i);
+				if (!ck(i, out var sub, error))
+					return false;
 				satisfyCost += sub.SatisfyCost;
 				dissatisfyCost += sub.DissatCost.Value;
 			}
@@ -342,28 +344,40 @@ internal double Cost1d(double satProb, double? dissatProb)
 
 		internal static AstElemExt<TPk, TPKh> Terminal(Terminal<TPk, TPKh> ast)
 		{
-			return new AstElemExt<TPk, TPKh>(Property<CompilerExtData, TPk, TPKh>.TypeCheck(ast), Miniscript<TPk, TPKh>.FromAst(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 AstElemExt<TPk, TPKh> Binary(Terminal<TPk, TPKh> ast, AstElemExt<TPk, TPKh> l, AstElemExt<TPk, TPKh> r)
+		internal static  bool TryConstructBinary(
+			Terminal<TPk, TPKh> ast,
+			AstElemExt<TPk, TPKh> l,
+			AstElemExt<TPk, TPKh> r,
+			out AstElemExt<TPk, TPKh> result,
+			List<FragmentPropertyException> errors)
 		{
-			var ty = Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(ast);
-			var ext = Property<ExtData, TPk, TPKh>.TypeCheck(ast);
-
+			result = null;
 			Func<int, CompilerExtData> lookupExt =
 				(int n) => n == 0 ? l.CompExtData : n == 1 ? r.CompExtData : throw new Exception("Unreachable");
-			var compExtData = Property<CompilerExtData, TPk, TPKh>.TypeCheck(ast, lookupExt);
-
-			return new AstElemExt<TPk, TPKh>(compExtData, new Miniscript<TPk, TPKh>(ty, ast, ext));
+			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 AstElemExt<TPk, TPKh> Ternary(
+		internal static bool TryConstructTernary(
 			Terminal<TPk, TPKh> ast,
 			AstElemExt<TPk, TPKh> a,
 			AstElemExt<TPk, TPKh> b,
-			AstElemExt<TPk, TPKh> c
-		)
+			AstElemExt<TPk, TPKh> c,
+			out AstElemExt<TPk, TPKh> result,
+			List<FragmentPropertyException> errors)
 		{
+			result = null;
 			Func<int, CompilerExtData> lookupExt =
 				n =>
 					n == 0 ? a.CompExtData :
@@ -371,11 +385,14 @@ AstElemExt<TPk, TPKh> c
 					n == 2 ? c.CompExtData :
 					throw new Exception("Unreachable");
 
-			var ty = Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(ast);
-			var ext = Property<ExtData, TPk, TPKh>.TypeCheck(ast);
-			var compilerExtData = Property<CompilerExtData, TPk, TPKh>.TypeCheck(ast, lookupExt);
-
-			return new AstElemExt<TPk, TPKh>(compilerExtData, new Miniscript<TPk, TPKh>(ty, ast, ext));
+			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()
 		{
@@ -857,7 +874,13 @@ private static IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> BestCompilatio
 					}
 
 					var astResult = Terminal<TPk, TPKh>.NewThresh(pol.Item1, subAst);
-					new CompilerExtData().TryThreshold((int) pol.Item1, n, index => subExtData[index],
+					IProperty<CompilerExtData>.SubCk subCk =
+						(int i, out CompilerExtData data, List<FragmentPropertyException> errors) =>
+						{
+							data = subExtData[i];
+							return true;
+						};
+					new CompilerExtData().TryThreshold((int) pol.Item1, n, subCk,
 						out var newThresh, new List<FragmentPropertyException>());
 					var astExtResult = new AstElemExt<TPk, TPKh>(
 							newThresh,
@@ -917,6 +940,7 @@ private static void CompileBinary(
 			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)
@@ -924,11 +948,8 @@ Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> binFunc
 					var ast = binFunc(l.Ms, r.Ms);
 					l.CompExtData.BranchProb = weights.Item1;
 					r.CompExtData.BranchProb = weights.Item2;
-					try
-					{
-						var newExt = AstElemExt<TPk, TPKh>.Binary(ast, l, r);
+					if (AstElemExt<TPk, TPKh>.TryConstructBinary(ast, l, r, out var newExt, errors))
 						InsertBestWrapped(policyCache, policy, ret, newExt, satProb, dissatProb);
-					} catch (FragmentPropertyException) {}
 				}
 			}
 		}
@@ -946,6 +967,7 @@ private static void CompileTernary(
 			double? dissatProb
 			)
 		{
+			var errors = new List<FragmentPropertyException>();
 			foreach (var a in aComp.Values)
 			{
 				foreach (var b in bComp.Values)
@@ -956,12 +978,8 @@ private static void CompileTernary(
 						b.CompExtData.BranchProb = weights.Item1;
 						c.CompExtData.BranchProb = weights.Item2;
 						var ast = Terminal<TPk, TPKh>.NewAndOr(a.Ms, b.Ms, c.Ms);
-						try
-						{
-							var newExt = AstElemExt<TPk, TPKh>.Ternary(ast, a, b, c);
+						if (AstElemExt<TPk, TPKh>.TryConstructTernary(ast, a, b, c, out var newExt, errors))
 							InsertBestWrapped(policyCache, policy, ret, newExt, satProb, dissatProb);
-						} catch (FragmentPropertyException ex)
-						{}
 					}
 				}
 			}
@@ -989,7 +1007,7 @@ public static Miniscript<TPk, TPKh> BestCompilation(ConcretePolicy<TPk, TPKh> po
 		/// <param name="dissatProb"></param>
 		/// <returns></returns>
 		/// <exception cref="NotImplementedException"></exception>
-		private static AstElemExt<TPk, TPKh> BestT(
+		internal static AstElemExt<TPk, TPKh> BestT(
 			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
 				policyCache,
 			ConcretePolicy<TPk, TPKh> policy,
diff --git a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
index 94e3167cb7..298dd5caa1 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
@@ -475,13 +475,14 @@ public override bool TryAndOr(Correctness a, Correctness b, Correctness c, out C
 			return true;
 		}
 
-		public override bool TryThreshold(int k, int n, Func<int, Correctness> subCk, out Correctness result, List<FragmentPropertyException> error)
+		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++)
 			{
-				var subType = subCk(i);
+				if (!ck(i, out var subType, error))
+					return false;
 				if (i == 0)
 				{
 					isN &= subType.Input == Input.OneNonZero || subType.Input == Input.AnyNonZero;
diff --git a/NBitcoin/Scripting/Miniscript/Types/ExtData.cs b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
index b01569c926..3fae6efe1f 100644
--- a/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/ExtData.cs
@@ -429,8 +429,9 @@ public override bool TryAndOr(ExtData a, ExtData b, ExtData c, out ExtData resul
 			return true;
 		}
 
-		public override bool TryThreshold(int k, int n, Func<int, ExtData> subCk, out ExtData result, List<FragmentPropertyException> error)
+		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;
@@ -441,7 +442,8 @@ public override bool TryThreshold(int k, int n, Func<int, ExtData> subCk, out Ex
 			var satCount = 0;
 			for (int i = 0; i < n; i++)
 			{
-				var sub = subCk(i);
+				if (!ck(i, out var sub, error))
+					return false;
 				pkCost += sub.PkCost;
 				opsCountStatic += sub.OpsCountStatic;
 				if (sub.OpsCountSat.HasValue && sub.OpsCountNSat.HasValue)
diff --git a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
index 2db7b02425..afd7d29966 100644
--- a/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/IProperty.cs
@@ -54,7 +54,9 @@ public virtual bool TryAndN(T l, T r, out T result, List<FragmentPropertyExcepti
 		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 abstract bool TryThreshold(int k, int n, Func<int, T> subCk, 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
index eb43c7129e..48bec44315 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -264,14 +264,16 @@ public override bool TryAndOr(Malleability a, Malleability b, Malleability c, ou
 			return true;
 		}
 
-		public override bool TryThreshold(int k, int n, Func<int, Malleability> subCk, out Malleability result, List<FragmentPropertyException> error)
+		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++)
 			{
-				var subType = subCk(i);
+				if (!ck(i, out var subType, error))
+					return false;
 				safeCount += (subType.Safe ? 1 : 0);
 				allAreDissatUnique &= subType.Dissat == Dissat.Unique;
 				allAreNonMalleable &= subType.NonMalleable;
diff --git a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
index ee2ec3cd8b..90bc9acf7f 100644
--- a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
@@ -343,12 +343,34 @@ public override bool TryAndOr(MiniscriptFragmentType a, MiniscriptFragmentType b
 
 
 
-		public override bool TryThreshold(int k, int n, Func<int, MiniscriptFragmentType> func,
+		public override bool TryThreshold(int k, int n, SubCk subCk,
 			out MiniscriptFragmentType result, List<FragmentPropertyException> error)
 		{
 			result = null;
-			if (new Correctness().TryThreshold(k, n, i => func(i).Correctness, out var corr, error)
-			    && new Malleability().TryThreshold(k, n, i => func(i).Malleability, out var mall, error)
+			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 subCorr, List<FragmentPropertyException> list) =>
+				{
+					subCorr = null;
+					if (subCk(i, out var subResult, error))
+					{
+						subCorr = 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);
diff --git a/NBitcoin/Scripting/Miniscript/Types/Property.cs b/NBitcoin/Scripting/Miniscript/Types/Property.cs
index de78c1f7d6..3167272cf1 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Property.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Property.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Runtime.InteropServices;
 using NBitcoin.Scripting.Miniscript.Policy;
 
 namespace NBitcoin.Scripting.Miniscript.Types
@@ -15,168 +16,169 @@ internal static class Property<T, TPk, TPKh>
 		/// the types of its children, if available and relevant for the
 		/// given fragment.
 		/// </summary>
-		internal static T TypeCheck(Terminal<TPk, TPKh> fragment, Func<int, T> child)
+		internal static bool TryTypeCheck(Terminal<TPk, TPKh> fragment, Func<int, T> child, out T res, List<FragmentPropertyException> errors)
 		{
-			var res = TypeCheckCore(fragment, child);
-			res.SanityChecks();
-			return res;
+			if (TryTypeCheckCore(fragment, child, out res, errors))
+			{
+				res.SanityChecks();
+				return true;
+			}
+			return false;
 		}
 
-		internal static T TypeCheck(Terminal<TPk, TPKh> fragment)
-			=> TypeCheck(fragment, (_) => null);
+		internal static bool TypeCheck(Terminal<TPk, TPKh> fragment, out T res, List<FragmentPropertyException> errors)
+			=> TryTypeCheck(fragment, (_) => null, out res, errors);
 
-		private static T TypeCheckCore(Terminal<TPk, TPKh> fragment,Func<int, T> child)
+		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));
 
-			T GetChild(Terminal<TPk, TPKh> sub, int n)
+			bool TryGetChild(Terminal<TPk, TPKh> sub, int n, out T subResult)
 				{
 						var r = child(n);
 						if (r is null)
-							return TypeCheck(sub, _ => null);
-						return r;
+							return TryTypeCheck(sub, _ => null, out subResult, errors);
+						subResult = r;
+						return true;
 				}
 
 			switch (fragment.Tag)
 			{
 				case Terminal<TPk, TPKh>.Tags.True:
-					return new T().FromTrue();
+					result = new T().FromTrue();
+					return true;
 				case Terminal<TPk, TPKh>.Tags.False:
-					return new T().FromFalse();
+					result = new T().FromFalse();
+					return true;
 			}
 
-			var errors = new List<FragmentPropertyException>();
-			T res;
-
 			switch (fragment)
 			{
 				case Terminal<TPk, TPKh>.Pk self:
-					return new T().FromPk();
+					result = new T().FromPk();
+					return true;
 				case Terminal<TPk, TPKh>.PkH self:
-					return new T().FromPkH();
+					result = new T().FromPkH();
+					return true;
 				case Terminal<TPk, TPKh>.ThreshM self:
 					if (self.Item1 == 0)
 					{
-						throw FragmentPropertyException.ZeroThreshold(fragment.ToString());
+						errors.Add(FragmentPropertyException.ZeroThreshold(fragment.ToString()));
+						return false;
 					}
 
 					if (self.Item1 > self.Item2.Length)
 					{
-						throw FragmentPropertyException.OverThreshold(
+						errors.Add(FragmentPropertyException.OverThreshold(
 							fragment.ToString()
-							);
+						));
+						return false;
 					}
-					return new T().FromMulti((int)self.Item1, self.Item2.Length);
+					result = new T().FromMulti((int)self.Item1, self.Item2.Length);
+					return true;
 				case Terminal<TPk, TPKh>.After self:
 					if (self.Item == 0)
 					{
-						throw FragmentPropertyException.ZeroTime(fragment.ToString());
+						errors.Add(FragmentPropertyException.ZeroTime(fragment.ToString()));
+						return false;
 					}
 
-					return new T().FromAfter(self.Item);
+					result = new T().FromAfter(self.Item);
+					return true;
 				case Terminal<TPk, TPKh>.Older self:
 					if (self.Item == 0)
 					{
-						throw FragmentPropertyException.ZeroTime(fragment.ToString());
+						errors.Add(FragmentPropertyException.ZeroTime(fragment.ToString()));
+						return false;
 					}
 
-					return new T().FromOlder(self.Item);
+					result = new T().FromOlder(self.Item);
+					return true;
 				case Terminal<TPk, TPKh>.Sha256 self:
-					return new T().FromSha256();
+					result = new T().FromSha256();
+					return true;
 				case Terminal<TPk, TPKh>.Hash256 self:
-					return new T().FromHash256();
+					result = new T().FromHash256();
+					return true;
 				case Terminal<TPk, TPKh>.Ripemd160 self:
-					return new T().FromRipemd160();
+					result = new T().FromRipemd160();
+					return true;
 				case Terminal<TPk, TPKh>.Hash160 self:
-					return new T().FromHash160();
+					result = new T().FromHash160();
+					return true;
 				case Terminal<TPk, TPKh>.Alt self:
-					if (GetChild(self.Item.Node, 0).TryCastAlt(out res, errors))
-						return res;
-					throw errors.Flatten();
+					return (TryGetChild(self.Item.Node, 0, out var subAlt) && subAlt.TryCastAlt(out result, errors));
 				case Terminal<TPk, TPKh>.Swap self:
-					if (GetChild(self.Item.Node, 0).TryCastSwap(out res, errors))
-						return res;
-					throw errors.Flatten();
+					return (TryGetChild(self.Item.Node, 0, out var subSwap) && subSwap.TryCastSwap(out result, errors));
 				case Terminal<TPk, TPKh>.Check self:
-					if (GetChild(self.Item.Node, 0).TryCastCheck(out res, errors))
-						return res;
-					throw errors.Flatten();
+					return (TryGetChild(self.Item.Node, 0, out var subCheck) && subCheck.TryCastCheck(out result, errors));
 				case Terminal<TPk, TPKh>.DupIf self:
-					if (GetChild(self.Item.Node, 0).TryCastDupIf(out res, errors))
-						return res;
-					throw errors.Flatten();
+					return (TryGetChild(self.Item.Node, 0, out var subDupIf) && subDupIf.TryCastDupIf(out result, errors));
 				case Terminal<TPk, TPKh>.Verify self:
-					if (GetChild(self.Item.Node, 0).TryCastVerify(out res, errors))
-						return res;
-					throw errors.Flatten();
+					return (TryGetChild(self.Item.Node, 0, out var subVerify) &&
+					        subVerify.TryCastVerify(out result, errors));
 				case Terminal<TPk, TPKh>.NonZero self:
-					if (GetChild(self.Item.Node, 0).TryCastNonZero(out res, errors))
-						return res;
-					throw errors.Flatten();
+					return (TryGetChild(self.Item.Node, 0, out var subNonZero) &&
+					        subNonZero.TryCastNonZero(out result, errors));
 				case Terminal<TPk, TPKh>.ZeroNotEqual self:
-					if (GetChild(self.Item.Node, 0).TryCastZeroNotEqual(out res, errors))
-						return res;
-					throw errors.Flatten();
+					return (TryGetChild(self.Item.Node, 0, out var sub0NotEqual) &&
+					        sub0NotEqual.TryCastZeroNotEqual(out result, errors));
 				case Terminal<TPk, TPKh>.AndB self:
-					var andBL = GetChild(self.Item1.Node, 0);
-					var andBR = GetChild(self.Item2.Node, 1);
-					if (new T().TryAndB(andBL, andBR, out res, errors))
-						return res;
-					throw errors.Flatten();
+					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:
-					var andVL = GetChild(self.Item1.Node, 0);
-					var andVR = GetChild(self.Item2.Node, 1);
-					if (new T().TryAndV(andVL, andVR, out res, errors))
-						return res;
-					throw errors.Flatten();
+					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:
-					var orBL = GetChild(self.Item1.Node, 0);
-					var orBR = GetChild(self.Item2.Node, 1);
-					if (new T().TryOrB(orBL, orBR, out res, errors))
-						return res;
-					throw errors.Flatten();
+					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:
-					var orDL = GetChild(self.Item1.Node, 0);
-					var orDR = GetChild(self.Item2.Node, 1);
-					if (new T().TryOrD(orDL, orDR, out res, errors))
-						return res;
-					throw errors.Flatten();
+					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:
-					var orCL = GetChild(self.Item1.Node, 0);
-					var orCR = GetChild(self.Item2.Node, 1);
-					if (new T().TryOrC(orCL, orCR, out res, errors))
-						return res;
-					throw errors.Flatten();
+					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:
-					var orIL = GetChild(self.Item1.Node, 0);
-					var orIR = GetChild(self.Item2.Node, 1);
-					if (new T().TryOrI(orIL, orIR, out res, errors))
-						return res;
-					throw errors.Flatten();
+					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:
-					var a = GetChild(self.Item1.Node, 0);
-					var b = GetChild(self.Item2.Node, 1);
-					var c = GetChild(self.Item3.Node, 2);
-					if (new T().TryAndOr(a, b, c, out res, errors))
-						return res;
-					throw errors.Flatten();
+					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)
 					{
-						throw FragmentPropertyException.ZeroThreshold(fragment.ToString());
+						errors.Add(FragmentPropertyException.ZeroThreshold(fragment.ToString()));
+						return false;
 					}
 
 					if (self.Item1 > self.Item2.Length)
 					{
-						throw FragmentPropertyException.OverThreshold(fragment.ToString());
+						errors.Add(FragmentPropertyException.OverThreshold(fragment.ToString()));
+						return false;
 					}
-					if (new T().TryThreshold(
-						(int)self.Item1,
-						self.Item2.Length, (n) =>
-							GetChild(self.Item2[n].Node, (int)n), out res, errors))
-						return res;
-					throw errors.Flatten();
+
+					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}");;
 		}

From 157888bf06e1982c29ab5c14d65e116646491b9a Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sat, 16 Nov 2019 00:40:44 +0900
Subject: [PATCH 37/50] Fix some obvious bugs in ToString and Equals

---
 NBitcoin.Tests/MiniscriptTests.cs           | 33 ++++++++++++++++-----
 NBitcoin/Scripting/Miniscript/AstElem.cs    | 15 ++++------
 NBitcoin/Scripting/Miniscript/Miniscript.cs |  5 +++-
 3 files changed, 36 insertions(+), 17 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index e7333b4a09..a82cd80c0e 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -253,17 +253,22 @@ public void ConcretePolicyUnitTest()
 			Assert.Equal(concreteP2_1.GetHashCode(), concreteP2_2.GetHashCode());
 		}
 
-		private void PolicyCompileLiftCheck(string s)
+		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 CompilerUnitTest()
+		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)"));
@@ -273,12 +278,26 @@ public void CompilerUnitTest()
 
 			// 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]}))");
-			PolicyCompileLiftCheck($"or(pk({PubKeys[0]}),pk({PubKeys[1]}))");
-			PolicyCompileLiftCheck($"thresh(2,pk({PubKeys[0]}),pk({PubKeys[1]}),pk({PubKeys[2]}))");
-			PolicyCompileLiftCheck($"or(1@and(pk({PubKeys[0]}),pk({PubKeys[1]})),127@pk({PubKeys[2]}))");
+			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]
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 9b513577c5..3b8ac94401 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -1173,15 +1173,12 @@ private StringBuilder ToStringCore(StringBuilder sb)
 					return sb.Append($"ripemd160({self.Item})");
 				case Hash160 self:
 					return sb.Append($"hash160({self.Item})");
-				case AndV self:
-					if (!self.Item2.Node.Equals(True))
-					{
-						sb.Append("and_v(");
-						self.Item1.Node.ToStringCore(sb);
-						sb.Append(",");
-						self.Item2.Node.ToStringCore(sb);
-						sb.Append(")");
-					}
+				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(");
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index d2b600c14e..777008a41c 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -7,7 +7,7 @@
 namespace NBitcoin.Scripting.Miniscript
 {
 	[DebuggerDisplay("{" + nameof(ToDebugString) + "()}")]
-	public partial class Miniscript<TPk, TPKh>
+	public partial class Miniscript<TPk, TPKh> : IEquatable<Miniscript<TPk, TPKh>>
 		where TPk : class, IMiniscriptKey<TPKh>, new()
 		where TPKh : class, IMiniscriptKeyHash, new()
 	{
@@ -67,5 +67,8 @@ public override string ToString()
 
 		public string ToDebugString() =>
 			Node.ToDebugString();
+
+		public bool Equals(Miniscript<TPk, TPKh> other)
+			=> this.Node.Equals(other.Node);
 	}
 }

From 021dac0cff75b336b8e1e31cb04012cd82ac86af Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sun, 17 Nov 2019 12:39:44 +0900
Subject: [PATCH 38/50] Fix some compiler bugs

---
 NBitcoin.Tests/MiniscriptTests.cs             | 25 ++++++++++++++++---
 NBitcoin/Scripting/Miniscript/AstElem.cs      |  2 +-
 NBitcoin/Scripting/Miniscript/ILiftable.cs    |  3 ++-
 .../Scripting/Miniscript/Policy/Compiler.cs   |  4 +--
 .../Scripting/Miniscript/Types/Correctness.cs |  2 +-
 5 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index a82cd80c0e..10e25a897c 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -207,6 +207,14 @@ public void MiniscriptAttributesTest(
 			}
 		}
 
+		[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")]
@@ -280,6 +288,16 @@ public void CompilerUnitTestInvalid()
 			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck($"and(pk({PubKeys[0]}),or(after(9),after(9)))"));
 		}
 
+		[Fact]
+		[Trait("UnitTest", "UnitTest")]
+		public void CompilerUnitTestValidTmp()
+		{
+			PolicyCompileLiftCheck(
+				$"or(pk({PubKeys[0]}),pk({PubKeys[1]}))",
+				$"or_b(c:pk({PubKeys[0]}),sc:pk({PubKeys[1]}))"
+				);
+		}
+
 		[Fact]
 		[Trait("UnitTest", "UnitTest")]
 		public void CompilerUnitTestValid()
@@ -288,14 +306,15 @@ public void CompilerUnitTestValid()
 			// successful case
 			PolicyCompileLiftCheck(
 				$"and(pk({PubKeys[0]}),pk({PubKeys[1]}))",
-				$"c:and_v(vc: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]}))"
+					$"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]})"
+					$"thresh_m(2,{PubKeys[0]},{PubKeys[1]},{PubKeys[2]})"
 				);
 			// PolicyCompileLiftCheck($"or(1@and(pk({PubKeys[0]}),pk({PubKeys[1]})),127@pk({PubKeys[2]}))");
 		}
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 3b8ac94401..41ca092545 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -1121,7 +1121,6 @@ public override string ToString()
 		/// append a character to display before the `:` as well as a reference
 		/// to the wrapped type to allow easy recursion.
 		/// </summary>
-		/// <param name="???"></param>
 		/// <returns></returns>
 		private Tuple<char, Miniscript<TPk, TPKh>> WrapChar()
 		{
@@ -1270,6 +1269,7 @@ private StringBuilder ToDebugStringCore(StringBuilder sb)
 				errors))
 			{
 				sb.Append(typeMap.Correctness.Base);
+				sb.Append("/");
 				sb.Append(typeMap.Correctness.Input.DebugPrint());
 				if (typeMap.Correctness.DisSatisfiable)
 					sb.Append('d');
diff --git a/NBitcoin/Scripting/Miniscript/ILiftable.cs b/NBitcoin/Scripting/Miniscript/ILiftable.cs
index 3c65ffb124..405d6552dd 100644
--- a/NBitcoin/Scripting/Miniscript/ILiftable.cs
+++ b/NBitcoin/Scripting/Miniscript/ILiftable.cs
@@ -43,6 +43,7 @@ public AbstractPolicy<TPk, TPKh> Lift()
 				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();
@@ -73,7 +74,7 @@ public AbstractPolicy<TPk, TPKh> Lift()
 						).Normalize();
 			}
 
-			throw new Exception("Unreachable!");
+			throw new Exception($"Unreachable! {this}");
 		}
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index ee68942fca..1c2b6db5bc 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -229,11 +229,11 @@ public override bool TryOrB(CompilerExtData left, CompilerExtData right, out Com
 		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 = left.BranchProb.Value; // and for right branch.
+			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
+				right.DissatCost + left.DissatCost.Value
 				);
 			return true;
 		}
diff --git a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
index 298dd5caa1..0d430aa323 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
@@ -360,7 +360,7 @@ public override bool TryOrD(Correctness l, Correctness r, out Correctness result
 				return false;
 			}
 
-			if (l.Base != Base.B)
+			if (l.Base != Base.B || r.Base != Base.B)
 			{
 				error.Add(FragmentPropertyException.ChildBase2(l.Base, r.Base));
 				return false;

From e67563a1a737f5016d0e1119e8ebb7a1911cba5a Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sun, 17 Nov 2019 15:06:46 +0900
Subject: [PATCH 39/50] Fix every compiler bug caused by FragmentType Equality

---
 NBitcoin.Tests/MiniscriptTests.cs                   | 13 ++-----------
 NBitcoin/Scripting/Miniscript/Types/Malleability.cs |  2 +-
 .../Miniscript/Types/MiniscriptFragmentType.cs      |  6 ++++++
 3 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 10e25a897c..2544ef1afe 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -274,6 +274,7 @@ private void PolicyCompileLiftCheck(string s, string expected = null)
 				Assert.Equal(expectedMs.Node, ms.Node);
 			}
 		}
+
 		[Fact]
 		[Trait("UnitTest", "UnitTest")]
 		public void CompilerUnitTestInvalid()
@@ -288,16 +289,6 @@ public void CompilerUnitTestInvalid()
 			Assert.Throws<CompilerException>(() => PolicyCompileLiftCheck($"and(pk({PubKeys[0]}),or(after(9),after(9)))"));
 		}
 
-		[Fact]
-		[Trait("UnitTest", "UnitTest")]
-		public void CompilerUnitTestValidTmp()
-		{
-			PolicyCompileLiftCheck(
-				$"or(pk({PubKeys[0]}),pk({PubKeys[1]}))",
-				$"or_b(c:pk({PubKeys[0]}),sc:pk({PubKeys[1]}))"
-				);
-		}
-
 		[Fact]
 		[Trait("UnitTest", "UnitTest")]
 		public void CompilerUnitTestValid()
@@ -316,7 +307,7 @@ public void CompilerUnitTestValid()
 				$"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]}))");
+			PolicyCompileLiftCheck($"or(1@and(pk({PubKeys[0]}),pk({PubKeys[1]})),127@pk({PubKeys[2]}))");
 		}
 
 		[Fact]
diff --git a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
index 48bec44315..5e4e3eaac9 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -62,7 +62,7 @@ public Malleability() {}
 
 		internal bool IsSubtype(Malleability other) =>
 			Dissat.IsSubType(other.Dissat) &&
-				other.Safe &&
+				!(!this.Safe && other.Safe) &&
 				!(!NonMalleable && other.NonMalleable);
 
 		public override Malleability FromTrue() =>
diff --git a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
index 90bc9acf7f..012cb0752a 100644
--- a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
@@ -385,6 +385,9 @@ 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);
 
@@ -393,6 +396,9 @@ 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;

From 91f88430feb40b9ad056e28469a3fde294c21ce9 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sun, 17 Nov 2019 18:32:30 +0900
Subject: [PATCH 40/50] update compiler tests

---
 NBitcoin.Tests/MiniscriptTests.cs             | 66 ++++++++++++++++++-
 .../PropertyTest/MiniscriptPropertyTests.cs   |  2 +-
 .../Scripting/Miniscript/Policy/Compiler.cs   | 22 ++++---
 .../Types/MiniscriptFragmentType.cs           |  6 +-
 4 files changed, 83 insertions(+), 13 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 2544ef1afe..43b22df30f 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -16,11 +16,14 @@ public class MiniscriptTests
 
 		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();
@@ -310,12 +313,62 @@ public void CompilerUnitTestValid()
 			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 CompileQ()
 		{
-			// var policy = ConcretePolicy<PubKey, uint160>.Parse($"or(1@and(pk({PubKeys[0]}),pk({PubKeys[1]})),127@pk({PubKeys[2]}))");
 			/*
+			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>>>(),
@@ -326,6 +379,17 @@ public void CompileQ()
 			Assert.Equal(compilation.Cost1d(1.0, null), 88.0 + 74.109375);
 			Assert.Equal(policy.Lift(), compilation.Ms.Lift());
 			*/
+
+			var policy2 = ConcretePolicy<PubKey, uint160>.Parse($"and(and(and(or(127@thresh(2,pk({PubKeys[0]}),pk({PubKeys[1]}),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))),pk({PubKeys[1]}))),1@pk({PubKeys[2]})),sha256(66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925)),or(127@pk({PubKeys[3]}),1@after(300))),or(127@after(400),pk({PubKeys[4]})))");
+			var compilation2 = Compiler<PubKey, uint160>.BestT(
+				new Dictionary<Tuple<ConcretePolicy<PubKey, uint160>, double, double?>,
+					IDictionary<CompilationKey, AstElemExt<PubKey, uint160>>>(),
+				policy2,
+				1.0,
+				null
+			);
+			Assert.Equal(compilation2.Cost1d(1.0, null), 437.0 + 299.4003295898438);
+			Assert.Equal(policy2.Lift(), compilation2.Ms.Lift());
 		}
 	}
 }
diff --git a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
index c366492d62..fb30a8bcda 100644
--- a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
+++ b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
@@ -27,7 +27,7 @@ public void ShouldBidirectionallyConvertConcretePolicyToString(ConcretePolicy<Pu
 			Assert.Equal(p.GetHashCode(), c.GetHashCode());
 		}
 
-		[Property(MaxTest = 100, Skip="For now")]
+		[Property(MaxTest = 100, Skip = "skip for now")]
 		[Trait("UnitTest", "UnitTest")]
 		public void ShouldCompileConcretePolicy(ConcretePolicy<PubKey, uint160> p)
 		{
diff --git a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index 1c2b6db5bc..676fe8693c 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -493,7 +493,7 @@ public List<AstElemExt<TPk, TPKh>> GetAllCasts()
 						resCompExtTrue,
 						new Miniscript<TPk,TPKh>(
 							resTypeTrue,
-							Terminal<TPk, TPKh>.NewAndV(ast.Ms, Miniscript<TPk, TPKh>.FromAst(Terminal<TPk, TPKh>.True)),
+							Terminal<TPk, TPKh>.NewAndV(ast.Ms, Miniscript<TPk, TPKh>.FromAst(Terminal<TPk, TPKh>.NewTrue())),
 							resExtTrue)
 					);
 				casts.Add(castTrue);
@@ -880,12 +880,18 @@ private static IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> BestCompilatio
 							data = subExtData[i];
 							return true;
 						};
-					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);
+					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)
@@ -1068,7 +1074,7 @@ private static AstElemExt<TPk, TPKh> BestE(
 					);
 		}
 
-		private static AstElemExt<TPk, TPKh> BestW(
+		internal static AstElemExt<TPk, TPKh> BestW(
 			IDictionary<Tuple<ConcretePolicy<TPk, TPKh>, double, double?>, IDictionary<CompilationKey, AstElemExt<TPk, TPKh>>>
 				policyCache,
 				ConcretePolicy<TPk, TPKh> policy,
diff --git a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
index 012cb0752a..cfaf99ee59 100644
--- a/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/MiniscriptFragmentType.cs
@@ -359,12 +359,12 @@ public override bool TryThreshold(int k, int n, SubCk subCk,
 					return false;
 				};
 			IProperty<Malleability>.SubCk getSubMalleability =
-				(int i, out Malleability subCorr, List<FragmentPropertyException> list) =>
+				(int i, out Malleability subMall, List<FragmentPropertyException> list) =>
 				{
-					subCorr = null;
+					subMall = null;
 					if (subCk(i, out var subResult, error))
 					{
-						subCorr = subResult.Malleability;
+						subMall = subResult.Malleability;
 						return true;
 					}
 					return false;

From 546c13b02aeecf1611094324afdee0a3d95b23ca Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sun, 17 Nov 2019 19:50:43 +0900
Subject: [PATCH 41/50] Fix bug in Malleability.CastTrue

---
 NBitcoin/Scripting/Miniscript/Types/Malleability.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
index 5e4e3eaac9..51fd605fc7 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Malleability.cs
@@ -145,7 +145,7 @@ public override bool TryCastZeroNotEqual(out Malleability result, List<FragmentP
 		public override bool TryCastTrue(out Malleability result, List<FragmentPropertyException> error)
 		{
 			result = new Malleability(
-				Dissat == Dissat.None ? Dissat.Unique : Dissat.Unknown,
+				Dissat.None,
 				Safe,
 				NonMalleable
 			);

From 48cdabd5594f3a3c291e5f9baa62ee8a01e90eaa Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Sun, 17 Nov 2019 23:20:58 +0900
Subject: [PATCH 42/50] Implement AbstractPolicy.Sort

---
 .../Miniscript/Policy/AbstractPolicy.cs       | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
index 2cf4dc49c5..62a9729724 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/AbstractPolicy.cs
@@ -427,5 +427,25 @@ private StringBuilder ToStringCore(StringBuilder sb)
 			}
 			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;
+		}
 	}
 }

From b7534c18255e60654031e298f82356e6d7f89589 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Mon, 18 Nov 2019 13:26:41 +0900
Subject: [PATCH 43/50] Remove some unused files

---
 .../Scripting/Miniscript/DSLTreeParser.cs     |   7 -
 NBitcoin/Scripting/Miniscript/Property.cs     |   3 -
 NBitcoin/Scripting/Miniscript/Satisfy.cs      | 175 ++++++++++++++++++
 NBitcoin/Scripting/Miniscript/Types/Types.cs  |   3 -
 4 files changed, 175 insertions(+), 13 deletions(-)
 delete mode 100644 NBitcoin/Scripting/Miniscript/DSLTreeParser.cs
 delete mode 100644 NBitcoin/Scripting/Miniscript/Property.cs
 create mode 100644 NBitcoin/Scripting/Miniscript/Satisfy.cs
 delete mode 100644 NBitcoin/Scripting/Miniscript/Types/Types.cs

diff --git a/NBitcoin/Scripting/Miniscript/DSLTreeParser.cs b/NBitcoin/Scripting/Miniscript/DSLTreeParser.cs
deleted file mode 100644
index f796a50b47..0000000000
--- a/NBitcoin/Scripting/Miniscript/DSLTreeParser.cs
+++ /dev/null
@@ -1,7 +0,0 @@
-namespace NBitcoin.Scripting.Miniscript
-{
-	public static class DSLTreeParser
-	{
-
-	}
-}
diff --git a/NBitcoin/Scripting/Miniscript/Property.cs b/NBitcoin/Scripting/Miniscript/Property.cs
deleted file mode 100644
index 08b060a601..0000000000
--- a/NBitcoin/Scripting/Miniscript/Property.cs
+++ /dev/null
@@ -1,3 +0,0 @@
-namespace NBitcoin.Scripting.Miniscript
-{
-}
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/Types/Types.cs b/NBitcoin/Scripting/Miniscript/Types/Types.cs
deleted file mode 100644
index 6f7523b44f..0000000000
--- a/NBitcoin/Scripting/Miniscript/Types/Types.cs
+++ /dev/null
@@ -1,3 +0,0 @@
-namespace NBitcoin.Scripting.Miniscript.Types
-{
-}

From 0a6b98d92f51c3e2aec2af520ad27c164af3946b Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Tue, 19 Nov 2019 15:55:35 +0900
Subject: [PATCH 44/50] Start writing deserializer

---
 .../PropertyTest/MiniscriptPropertyTests.cs   |   7 +-
 NBitcoin/Scripting/Miniscript/AstElem.cs      |  37 ++
 NBitcoin/Scripting/Miniscript/Miniscript.cs   |   3 +
 NBitcoin/Scripting/Miniscript/ScriptParser.cs | 142 +++++++
 NBitcoin/Scripting/Miniscript/ScriptToken.cs  | 202 +++++++++-
 .../Scripting/Parser/Parse.ScriptToken.cs     |  76 ++--
 NBitcoin/Scripting/Parser/Parser.cs           | 171 ++++----
 NBitcoin/Scripting/Parser/ScriptInput.cs      |  95 ++---
 NBitcoin/Scripting/ScriptExtensions.cs        | 377 +++++++++---------
 NBitcoin/Scripting/ScriptToken.cs             | 327 ---------------
 10 files changed, 746 insertions(+), 691 deletions(-)
 delete mode 100644 NBitcoin/Scripting/ScriptToken.cs

diff --git a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
index fb30a8bcda..bdbcf5679c 100644
--- a/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
+++ b/NBitcoin.Tests/PropertyTest/MiniscriptPropertyTests.cs
@@ -16,7 +16,7 @@ public MiniscriptPropertyTests()
 			Arb.Register<ConcretePolicyGenerator>();
 		}
 
-		[Property(MaxTest = 12)]
+		[Property(MaxTest = 100)]
 		[Trait("UnitTest", "UnitTest")]
 		public void ShouldBidirectionallyConvertConcretePolicyToString(ConcretePolicy<PubKey, uint160> p)
 		{
@@ -27,7 +27,7 @@ public void ShouldBidirectionallyConvertConcretePolicyToString(ConcretePolicy<Pu
 			Assert.Equal(p.GetHashCode(), c.GetHashCode());
 		}
 
-		[Property(MaxTest = 100, Skip = "skip for now")]
+		[Property(MaxTest = 400, Skip = "for now")]
 		[Trait("UnitTest", "UnitTest")]
 		public void ShouldCompileConcretePolicy(ConcretePolicy<PubKey, uint160> p)
 		{
@@ -36,9 +36,10 @@ public void ShouldCompileConcretePolicy(ConcretePolicy<PubKey, uint160> p)
 			var IsNonMalleable = t.Item2;
 			if (isSafe && IsNonMalleable)
 			{
-				Console.WriteLine($"Compiling {p}");
 				var ms = p.Compile();
 				Console.WriteLine($"Compiled {ms}");
+				var sc = ms.ToScript();
+				Console.WriteLine(sc);
 			}
 			else
 			{
diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 41ca092545..735bd664f5 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -103,16 +103,52 @@ public partial class Terminal<TPk, TPKh> : IEquatable<Terminal<TPk, TPKh>>
 		# 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;
@@ -120,6 +156,7 @@ internal static class Tags
 			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;
diff --git a/NBitcoin/Scripting/Miniscript/Miniscript.cs b/NBitcoin/Scripting/Miniscript/Miniscript.cs
index 777008a41c..ab046ab065 100644
--- a/NBitcoin/Scripting/Miniscript/Miniscript.cs
+++ b/NBitcoin/Scripting/Miniscript/Miniscript.cs
@@ -6,6 +6,9 @@
 
 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()
diff --git a/NBitcoin/Scripting/Miniscript/ScriptParser.cs b/NBitcoin/Scripting/Miniscript/ScriptParser.cs
index c37706de15..41411a4d18 100644
--- a/NBitcoin/Scripting/Miniscript/ScriptParser.cs
+++ b/NBitcoin/Scripting/Miniscript/ScriptParser.cs
@@ -1,7 +1,149 @@
+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 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 TerminalStackExtension
+	{
+		internal static void Reduce0<TPk, TPKh>(this Stack<Miniscript<TPk, TPKh>> self, Terminal<TPk, TPKh> term)
+			where TPk : class, IMiniscriptKey<TPKh>, new()
+			where TPKh : class, IMiniscriptKeyHash, new()
+		{
+			var e = new List<FragmentPropertyException>();
+			if (Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(term, out var ty, e)
+				&& Property<ExtData, TPk, TPKh>.TypeCheck(term, out var ext, e))
+				self.Push(new Miniscript<TPk,TPKh>(ty, term, ext));
+			throw new ParsingException("Failed to reduce");
+		}
+
+		internal static void Reduce1<TPk, TPKh>(
+			this Stack<Miniscript<TPk, TPKh>> self,
+			Func<Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> wrap)
+			where TPk : class, IMiniscriptKey<TPKh>, new()
+			where TPKh : class, IMiniscriptKeyHash, new()
+			=> self.Reduce0(wrap(self.Pop()));
+
+		internal static void Reduce2<TPk, TPKh>(
+			this Stack<Miniscript<TPk, TPKh>> self,
+			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> wrap)
+			where TPk : class, IMiniscriptKey<TPKh>, new()
+			where TPKh : class, IMiniscriptKeyHash, new()
+			=> self.Reduce0(wrap(self.Pop(), self.Pop()));
+	}
 	internal static class ScriptParser
 	{
+		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>()
+			select MS.FromAst(Terminal.NewPk(pk.Item));
+
+		private static readonly PM PCheckSig
+			=
+			from _c in Parse.ScriptToken(ScriptToken.CheckSig)
+			from sub in Parse.Ref(() => PExpr)
+			select MS.FromAst(Terminal.NewCheck(sub));
+
+		private static readonly PM PVerify
+			=
+			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)
+			select MS.FromAst(Terminal.NewPkH(hash20.Item));
+
+		private static readonly Parser<ScriptToken, MS> PExpr =
+			PPubkey
+				.Or(PCheckSig);
+		# region ported rust-miniscript
+
+		private class TermOrRecurse
+		{
+
+		}
 
+		/*
+		private static void MatchToken(Stack<ScriptToken> tokens, List<Tuple<int, Action<ScriptToken>>> action)
+		{
+			if (tokens.Count() == 1)
+				action(tokens.First());
+			else if (tokens.TryPeek(out var token))
+			{
+				if (token.Equals(pattern.First()))
+				{
+					MatchToken(tokens, pattern.Skip(1).ToList(), action);
+				}
+				else
+				{
+					throw new ParsingException($"Unexpected {token}");
+				}
+			}
+			else
+				throw new ParsingException("Unexpected start!");
+		}
+		*/
+		public static Miniscript<TPk, TPKh> ParseMiniscript(Stack<ScriptToken> tokens)
+		{
+			var nonTerm = new Stack<NonTerm>();
+			var term = new Stack<Miniscript<TPk, TPKh>>();
+			nonTerm.Push(NonTerm.MaybeAndV);
+			nonTerm.Push(NonTerm.MaybeSwap);
+			nonTerm.Push(NonTerm.Expression);
+			while (true)
+			{
+				switch (nonTerm.Pop())
+				{
+					case NonTerm x when (x == NonTerm.Expression):
+						MatchToken(tokens, );
+						break;
+					case NonTerm x when (x == NonTerm.MaybeAndV):
+						if (tokens.TryPeek(out var maybeAndV))
+						{
+							if (!(maybeAndV.Equals(ScriptToken.If)
+							      || maybeAndV.Equals(ScriptToken.NotIf)
+							      || maybeAndV.Equals(ScriptToken.Else)
+							      || maybeAndV.Equals(ScriptToken.ToAltStack)))
+							{
+								nonTerm.Push(NonTerm.AndV);
+								nonTerm.Push(NonTerm.Expression);
+							}
+						}
+						break;
+					case NonTerm x when (x == NonTerm.MaybeSwap):
+						if (tokens.TryPeek(out var maybeSwap) && maybeSwap.Equals(ScriptToken.Swap))
+						{
+							tokens.Pop();
+							term.Reduce1(Terminal<TPk, TPKh>.NewSwap);
+							nonTerm.Push(NonTerm.MaybeSwap);
+						}
+						break;
+					case NonTerm x when (x == NonTerm.Alt):
+						break;
+					case NonTerm x when (x == NonTerm.Check):
+						break;
+				};
+			}
+		}
+		# endregion
 	}
 }
diff --git a/NBitcoin/Scripting/Miniscript/ScriptToken.cs b/NBitcoin/Scripting/Miniscript/ScriptToken.cs
index 45f781633b..3f9d4d68d3 100644
--- a/NBitcoin/Scripting/Miniscript/ScriptToken.cs
+++ b/NBitcoin/Scripting/Miniscript/ScriptToken.cs
@@ -1,7 +1,15 @@
 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
@@ -90,6 +98,7 @@ internal static class Tags
 		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);
@@ -157,14 +166,7 @@ public sealed override int GetHashCode()
 		}
 
 		public sealed override bool Equals(object obj)
-		{
-			ScriptToken token = obj as ScriptToken;
-			if (token != null)
-			{
-				return Equals(token);
-			}
-			return false;
-		}
+			=> Equals(obj as ScriptToken);
 		public bool Equals(ScriptToken obj)
 		{
 			if (obj == null)
@@ -206,10 +208,189 @@ public bool Equals(ScriptToken obj)
 			return false;
 		}
 
-		public static ScriptToken FromScript()
+		public static List<ScriptToken> FromScript(Script script)
 		{
-			throw new Exception("");
+			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;
+				}
+			}
+
+			return ret;
 		}
+
+		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)
@@ -279,6 +460,5 @@ public override string ToString()
 			}
 			throw new Exception("Unreachable");
 		}
-
 	}
 }
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/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..a38c0e1957 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(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; }
+	}
+}
diff --git a/NBitcoin/Scripting/ScriptExtensions.cs b/NBitcoin/Scripting/ScriptExtensions.cs
index 8aa5f48096..26b18253b7 100644
--- a/NBitcoin/Scripting/ScriptExtensions.cs
+++ b/NBitcoin/Scripting/ScriptExtensions.cs
@@ -1,188 +1,189 @@
-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
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NBitcoin.Scripting.Miniscript;
+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}");
+			}
+		}
+	}
+}
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

From 03e5506c04f539a4a8a109e3753a1acb68ac63c7 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Wed, 20 Nov 2019 00:44:30 +0900
Subject: [PATCH 45/50] Prepare deserilizer

---
 NBitcoin/Scripting/Miniscript/ScriptParser.cs | 390 +++++++++++++-----
 NBitcoin/Scripting/Miniscript/ScriptToken.cs  |   6 +-
 NBitcoin/Scripting/Parser/ScriptInput.cs      |   2 +-
 NBitcoin/Scripting/ScriptExtensions.cs        | 189 ---------
 4 files changed, 283 insertions(+), 304 deletions(-)
 delete mode 100644 NBitcoin/Scripting/ScriptExtensions.cs

diff --git a/NBitcoin/Scripting/Miniscript/ScriptParser.cs b/NBitcoin/Scripting/Miniscript/ScriptParser.cs
index 41411a4d18..798548ff32 100644
--- a/NBitcoin/Scripting/Miniscript/ScriptParser.cs
+++ b/NBitcoin/Scripting/Miniscript/ScriptParser.cs
@@ -5,9 +5,9 @@
 using NBitcoin.Scripting.Miniscript.Types;
 using NBitcoin.Scripting.Parser;
 
-/// When parsing from 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.
+// 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<
@@ -18,35 +18,21 @@
 
 namespace NBitcoin.Scripting.Miniscript
 {
-	internal static class TerminalStackExtension
-	{
-		internal static void Reduce0<TPk, TPKh>(this Stack<Miniscript<TPk, TPKh>> self, Terminal<TPk, TPKh> term)
-			where TPk : class, IMiniscriptKey<TPKh>, new()
-			where TPKh : class, IMiniscriptKeyHash, new()
-		{
-			var e = new List<FragmentPropertyException>();
-			if (Property<MiniscriptFragmentType, TPk, TPKh>.TypeCheck(term, out var ty, e)
-				&& Property<ExtData, TPk, TPKh>.TypeCheck(term, out var ext, e))
-				self.Push(new Miniscript<TPk,TPKh>(ty, term, ext));
-			throw new ParsingException("Failed to reduce");
-		}
-
-		internal static void Reduce1<TPk, TPKh>(
-			this Stack<Miniscript<TPk, TPKh>> self,
-			Func<Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> wrap)
-			where TPk : class, IMiniscriptKey<TPKh>, new()
-			where TPKh : class, IMiniscriptKeyHash, new()
-			=> self.Reduce0(wrap(self.Pop()));
-
-		internal static void Reduce2<TPk, TPKh>(
-			this Stack<Miniscript<TPk, TPKh>> self,
-			Func<Miniscript<TPk, TPKh>, Miniscript<TPk, TPKh>, Terminal<TPk, TPKh>> wrap)
-			where TPk : class, IMiniscriptKey<TPKh>, new()
-			where TPKh : class, IMiniscriptKeyHash, new()
-			=> self.Reduce0(wrap(self.Pop(), self.Pop()));
-	}
 	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>()
@@ -55,95 +41,277 @@ private static readonly Parser<ScriptToken, uint> PNumber
 		private static readonly PM PPubkey
 			=
 			from pk in Parse.ScriptToken<ScriptToken.Pk>()
-			select MS.FromAst(Terminal.NewPk(pk.Item));
+			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)
-			select MS.FromAst(Terminal.NewCheck(sub));
+			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 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)
-			select MS.FromAst(Terminal.NewPkH(hash20.Item));
-
-		private static readonly Parser<ScriptToken, MS> PExpr =
-			PPubkey
-				.Or(PCheckSig);
-		# region ported rust-miniscript
-
-		private class TermOrRecurse
-		{
-
-		}
-
-		/*
-		private static void MatchToken(Stack<ScriptToken> tokens, List<Tuple<int, Action<ScriptToken>>> action)
-		{
-			if (tokens.Count() == 1)
-				action(tokens.First());
-			else if (tokens.TryPeek(out var token))
-			{
-				if (token.Equals(pattern.First()))
-				{
-					MatchToken(tokens, pattern.Skip(1).ToList(), action);
-				}
-				else
-				{
-					throw new ParsingException($"Unexpected {token}");
-				}
-			}
-			else
-				throw new ParsingException("Unexpected start!");
-		}
-		*/
-		public static Miniscript<TPk, TPKh> ParseMiniscript(Stack<ScriptToken> tokens)
-		{
-			var nonTerm = new Stack<NonTerm>();
-			var term = new Stack<Miniscript<TPk, TPKh>>();
-			nonTerm.Push(NonTerm.MaybeAndV);
-			nonTerm.Push(NonTerm.MaybeSwap);
-			nonTerm.Push(NonTerm.Expression);
-			while (true)
-			{
-				switch (nonTerm.Pop())
-				{
-					case NonTerm x when (x == NonTerm.Expression):
-						MatchToken(tokens, );
-						break;
-					case NonTerm x when (x == NonTerm.MaybeAndV):
-						if (tokens.TryPeek(out var maybeAndV))
-						{
-							if (!(maybeAndV.Equals(ScriptToken.If)
-							      || maybeAndV.Equals(ScriptToken.NotIf)
-							      || maybeAndV.Equals(ScriptToken.Else)
-							      || maybeAndV.Equals(ScriptToken.ToAltStack)))
-							{
-								nonTerm.Push(NonTerm.AndV);
-								nonTerm.Push(NonTerm.Expression);
-							}
-						}
-						break;
-					case NonTerm x when (x == NonTerm.MaybeSwap):
-						if (tokens.TryPeek(out var maybeSwap) && maybeSwap.Equals(ScriptToken.Swap))
-						{
-							tokens.Pop();
-							term.Reduce1(Terminal<TPk, TPKh>.NewSwap);
-							nonTerm.Push(NonTerm.MaybeSwap);
-						}
-						break;
-					case NonTerm x when (x == NonTerm.Alt):
-						break;
-					case NonTerm x when (x == NonTerm.Check):
-						break;
-				};
-			}
-		}
+			(
+				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
index 3f9d4d68d3..9db97de000 100644
--- a/NBitcoin/Scripting/Miniscript/ScriptToken.cs
+++ b/NBitcoin/Scripting/Miniscript/ScriptToken.cs
@@ -208,7 +208,7 @@ public bool Equals(ScriptToken obj)
 			return false;
 		}
 
-		public static List<ScriptToken> FromScript(Script script)
+		public static ScriptToken[] FromScript(Script script)
 		{
 			var ret = new List<ScriptToken>();
 			foreach (var s in script.ToOps())
@@ -363,8 +363,8 @@ public static List<ScriptToken> FromScript(Script script)
 						break;
 				}
 			}
-
-			return ret;
+			ret.Reverse();
+			return ret.ToArray();
 		}
 
 		private static ScriptToken GetItem(Op op)
diff --git a/NBitcoin/Scripting/Parser/ScriptInput.cs b/NBitcoin/Scripting/Parser/ScriptInput.cs
index a38c0e1957..4a8aa0fe60 100644
--- a/NBitcoin/Scripting/Parser/ScriptInput.cs
+++ b/NBitcoin/Scripting/Parser/ScriptInput.cs
@@ -7,7 +7,7 @@ namespace NBitcoin.Scripting.Parser
 {
 	internal class ScriptInput : IInput<ScriptToken>
 	{
-		public ScriptInput(Script source) : this(source.ToTokens(), 0) { }
+		public ScriptInput(Script source) : this(ScriptToken.FromScript(source), 0) { }
 
 		public ScriptInput(ScriptToken[] source) : this(source, 0) { }
 
diff --git a/NBitcoin/Scripting/ScriptExtensions.cs b/NBitcoin/Scripting/ScriptExtensions.cs
deleted file mode 100644
index 26b18253b7..0000000000
--- a/NBitcoin/Scripting/ScriptExtensions.cs
+++ /dev/null
@@ -1,189 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using NBitcoin.Scripting.Miniscript;
-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}");
-			}
-		}
-	}
-}

From d1d66c8d6e9eccf26237a3625764dc7655049f36 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Wed, 20 Nov 2019 18:50:55 +0900
Subject: [PATCH 46/50] Prepare DummyKey for testing

---
 NBitcoin.Tests/MiniscriptTests.cs             | 29 +++++++++++++---
 .../Scripting/Miniscript/MiniscriptKey.cs     | 33 ++++++++++++++++++-
 .../Scripting/Miniscript/Policy/Compiler.cs   |  8 +++++
 3 files changed, 65 insertions(+), 5 deletions(-)

diff --git a/NBitcoin.Tests/MiniscriptTests.cs b/NBitcoin.Tests/MiniscriptTests.cs
index 43b22df30f..a85a8decfe 100644
--- a/NBitcoin.Tests/MiniscriptTests.cs
+++ b/NBitcoin.Tests/MiniscriptTests.cs
@@ -14,6 +14,7 @@ public class MiniscriptTests
 	{
 		public static HexEncoder Hex = new DataEncoders.HexEncoder();
 
+
 		public static Key[] PrivKeys = (new[]
 			{
 				"4040404040404040404040404040404040404040404040404040404040404040",
@@ -363,6 +364,21 @@ public void CompileValidTmp()
 			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()
@@ -380,10 +396,10 @@ public void CompileQ()
 			Assert.Equal(policy.Lift(), compilation.Ms.Lift());
 			*/
 
-			var policy2 = ConcretePolicy<PubKey, uint160>.Parse($"and(and(and(or(127@thresh(2,pk({PubKeys[0]}),pk({PubKeys[1]}),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))),pk({PubKeys[1]}))),1@pk({PubKeys[2]})),sha256(66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925)),or(127@pk({PubKeys[3]}),1@after(300))),or(127@after(400),pk({PubKeys[4]})))");
-			var compilation2 = Compiler<PubKey, uint160>.BestT(
-				new Dictionary<Tuple<ConcretePolicy<PubKey, uint160>, double, double?>,
-					IDictionary<CompilationKey, AstElemExt<PubKey, uint160>>>(),
+			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
@@ -391,5 +407,10 @@ public void CompileQ()
 			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/Scripting/Miniscript/MiniscriptKey.cs b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
index 4d1333ca48..cc99a92fde 100644
--- a/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
+++ b/NBitcoin/Scripting/Miniscript/MiniscriptKey.cs
@@ -90,7 +90,30 @@ public bool Equals(IMiniscriptKey<MiniscriptStringKeyHash> other)
 		public static MiniscriptStringKey Parse(string str)
 			=> new MiniscriptStringKey(str);
 	}
-	public static class MiniscriptFragmentParser<TPk, TPKh>
+	/// <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()
 	{
@@ -107,6 +130,10 @@ public static TPk ParseKey(string str)
 			{
 				return MiniscriptStringKey.Parse(str) as TPk;
 			}
+			if (t is DummyKey)
+			{
+				return t;
+			}
 			throw new NotSupportedException();
 		}
 
@@ -117,6 +144,10 @@ public static TPKh ParseHash(string str)
 				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/Policy/Compiler.cs b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
index 676fe8693c..d35e7ede8c 100644
--- a/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
+++ b/NBitcoin/Scripting/Miniscript/Policy/Compiler.cs
@@ -907,6 +907,13 @@ private static IDictionary<CompilationKey, AstElemExt<TPk, TPKh>> BestCompilatio
 			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
@@ -1061,6 +1068,7 @@ private static AstElemExt<TPk, TPKh> BestE(
 						&& 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)

From 4ac52b113a9daa9c936a35002d55918c19590a92 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Wed, 20 Nov 2019 22:48:37 +0900
Subject: [PATCH 47/50] Fix bug in OrI.ToString

---
 NBitcoin/Scripting/Miniscript/AstElem.cs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 735bd664f5..64131e156c 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -1257,16 +1257,15 @@ private StringBuilder ToStringCore(StringBuilder sb)
 					sb.Append(",");
 					self.Item2.Node.ToStringCore(sb);
 					return sb.Append(")");
-				case OrI self:
-					if (self.Item1.Node != False && self.Item2.Node != False)
+				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;
 					}
-					return sb;
 				case Thresh self:
 					sb.Append("thresh(");
 					sb.Append(self.Item1);

From e5ac715f2f850e7da7492e0352e9926f5db061fd Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Wed, 20 Nov 2019 22:49:23 +0900
Subject: [PATCH 48/50] Fix bug in script num size

---
 NBitcoin/Scripting/Miniscript/Utils.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/NBitcoin/Scripting/Miniscript/Utils.cs b/NBitcoin/Scripting/Miniscript/Utils.cs
index 6ecbf3af2d..dcc761b9d8 100644
--- a/NBitcoin/Scripting/Miniscript/Utils.cs
+++ b/NBitcoin/Scripting/Miniscript/Utils.cs
@@ -7,7 +7,7 @@ internal static int ScriptNumSize(ulong n)
 		{
 			if (n <= 0x10) // OP_n
 				return 1;
-			if (n < 0x10) // OP_PUSH1 <n>
+			if (n < 0x80) // OP_PUSH1 <n>
 				return 2;
 			if (n < 0x8000) // OP_PUSH2 <n>
 				return 3;

From c65bcaf043e841e14855ba852d87e26cc51d9c26 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Thu, 21 Nov 2019 16:53:44 +0900
Subject: [PATCH 49/50] nitfix

* fix bug in Correctness.TryAndB
* fix debug format
---
 NBitcoin/Scripting/Miniscript/Input.cs             | 2 +-
 NBitcoin/Scripting/Miniscript/Types/Correctness.cs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/NBitcoin/Scripting/Miniscript/Input.cs b/NBitcoin/Scripting/Miniscript/Input.cs
index b0e0f2ea97..ff23eb7e13 100644
--- a/NBitcoin/Scripting/Miniscript/Input.cs
+++ b/NBitcoin/Scripting/Miniscript/Input.cs
@@ -17,7 +17,7 @@ internal static class InputExtension
 	{
 		public static string DebugPrint(this Input i)
 			=> (i == Input.Zero) ? "z" :
-				(i == Input.One) ? "0" :
+				(i == Input.One) ? "o" :
 				(i == Input.OneNonZero) ? "on" :
 				(i == Input.Any) ? "" :
 				(i == Input.AnyNonZero) ? "n" : "";
diff --git a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
index 0d430aa323..0a92aefe22 100644
--- a/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
+++ b/NBitcoin/Scripting/Miniscript/Types/Correctness.cs
@@ -262,7 +262,7 @@ public override bool TryAndB(Correctness l, Correctness r, out Correctness resul
 					? Input.Zero
 					:
 					((l.Input == Input.Zero && r.Input == Input.One)
-					 || l.Input == Input.One || r.Input == Input.Zero)
+					 || (l.Input == Input.One && r.Input == Input.Zero))
 						? Input.One
 						:
 						(l.Input == Input.Zero && r.Input == Input.OneNonZero)

From adb13908ce3c3d18952e6e232400552110e45f68 Mon Sep 17 00:00:00 2001
From: joemphilips <joemphilips@gmail.com>
Date: Thu, 21 Nov 2019 18:42:36 +0900
Subject: [PATCH 50/50] Simplicy AstElem.Equals by serializing to script

* There are the case which has same serialization format
 for the script, but we have different ast element representation
 (e.g. `and_v(X,v:Y)` and `v:and_v(X,Y)`)
 So the equality criteria for `Terminal<TPk,TPKh>` must be based on
 its script representation.
---
 NBitcoin/Scripting/Miniscript/AstElem.cs | 176 +----------------------
 1 file changed, 2 insertions(+), 174 deletions(-)

diff --git a/NBitcoin/Scripting/Miniscript/AstElem.cs b/NBitcoin/Scripting/Miniscript/AstElem.cs
index 64131e156c..63d90bfc58 100644
--- a/NBitcoin/Scripting/Miniscript/AstElem.cs
+++ b/NBitcoin/Scripting/Miniscript/AstElem.cs
@@ -425,182 +425,10 @@ public static Terminal<TPk, TPKh> NewThreshM(uint item1, IEnumerable<TPk> item2)
 
 		#region Equatable members
 		public bool Equals(Terminal<TPk, TPKh> other)
-		{
-			if (other == null)
-				return false;
-			if (this.Tag != other.Tag)
-				return false;
-
-			switch (this.Tag)
-			{
-				case Tags.True: return true;
-				case Tags.False: return true;
-			}
-
-			switch (this)
-			{
-				case Pk self:
-					return self.Item.Equals(((Pk) other).Item);
-				case PkH self:
-					return self.Item.Equals(((PkH) 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 Alt self:
-					return self.Item.Equals(((Alt) other).Item);
-				case Swap self:
-					return self.Item.Equals(((Swap) other).Item);
-				case Check self:
-					return self.Item.Equals(((Check) other).Item);
-				case DupIf self:
-					return self.Item.Equals(((DupIf) other).Item);
-				case Verify self:
-					return self.Item.Equals(((Verify) other).Item);
-				case NonZero self:
-					return self.Item.Equals(((NonZero) other).Item);
-				case ZeroNotEqual self:
-					return self.Item.Equals(((ZeroNotEqual) other).Item);
-				case AndV self:
-					var andv = (AndV) other;
-					return self.Item1.Equals(andv.Item1) && self.Item2.Equals(andv.Item2);
-				case AndB self:
-					var andb = (AndB) other;
-					return self.Item1.Equals(andb.Item1) && self.Item2.Equals(andb.Item2);
-				case AndOr self:
-					var andOr = (AndOr) other;
-					return self.Item1.Equals(andOr.Item1) && self.Item2.Equals(andOr.Item2) && self.Item3.Equals(andOr.Item3);
-				case OrB self:
-					var orb = (OrB) other;
-					return self.Item1.Equals(orb.Item1) && self.Item2.Equals(orb.Item2);
-				case OrD self:
-					var ord = (OrD) other;
-					return self.Item1.Equals(ord.Item1) && self.Item2.Equals(ord.Item2);
-				case OrC self:
-					var orc = (OrC) other;
-					return self.Item1.Equals(orc.Item1) && self.Item2.Equals(orc.Item2);
-				case OrI self:
-					var ori = (OrI) other;
-					return self.Item1.Equals(ori.Item1) && self.Item2.Equals(ori.Item2);
-				case Thresh self:
-					var t = (Thresh) other;
-					return self.Item1.Equals(t.Item1) && self.Item2.SequenceEqual(t.Item2);
-				case ThreshM self:
-					var tm = (ThreshM) other;
-					return self.Item1.Equals(tm.Item1) && self.Item2.SequenceEqual(tm.Item2);
-			}
-			throw new Exception("Unreachable!");
-		}
+			=> this.ToScript().Equals(other.ToScript());
 
 		public override int GetHashCode()
-		{
-
-			int num = 0;
-			switch (this.Tag)
-			{
-				case Tags.True: return Tags.True;
-				case Tags.False: return Tags.False;
-			}
-
-			switch (this)
-			{
-				case Pk self:
-					num = Tags.Pk;
-					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
-				case PkH self:
-					num = Tags.PkH;
-					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 Alt self:
-					num = Tags.Alt;
-					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
-				case Swap self:
-					num = Tags.Swap;
-					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
-				case Check self:
-					num = Tags.Check;
-					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
-				case DupIf self:
-					num = Tags.DupIf;
-					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
-				case Verify self:
-					num = Tags.Verify;
-					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
-				case NonZero self:
-					num = Tags.NonZero;
-					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
-				case ZeroNotEqual self:
-					num = Tags.ZeroNotEqual;
-					return -1640531527 + self.Item.GetHashCode() + ((num << 6) + (num >> 2));
-				case AndV self:
-					num = Tags.AndV;
-					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
-					return -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
-				case AndB self:
-					num = Tags.AndB;
-					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
-					return -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
-				case AndOr self:
-					num = Tags.AndOr;
-					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
-					num = -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
-					return -1640531527 + self.Item3.GetHashCode() + ((num << 6) + (num >> 2));
-				case OrB self:
-					num = Tags.OrB;
-					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
-					return -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
-				case OrD self:
-					num = Tags.OrD;
-					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
-					return -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
-				case OrC self:
-					num = Tags.OrC;
-					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
-					return -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
-				case OrI self:
-					num = Tags.OrI;
-					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
-					return -1640531527 + self.Item2.GetHashCode() + ((num << 6) + (num >> 2));
-				case Thresh self:
-					num = Tags.Thresh;
-					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
-					foreach (var sub in self.Item2)
-						num = -1640531527 + sub.GetHashCode() + ((num << 6) + (num >> 2));
-					return num;
-				case ThreshM self:
-					num = Tags.ThreshM;
-					num = -1640531527 + self.Item1.GetHashCode() + ((num << 6) + (num >> 2));
-					foreach (var sub in self.Item2)
-						num = -1640531527 + sub.GetHashCode() + ((num << 6) + (num >> 2));
-					return num;
-			}
-			throw new Exception("Unreachable!");
-		}
+			=> this.ToScript().GetHashCode();
 		#endregion
 
 		public Script ToScript() =>