WIP: Miniscript final version

NBitcoin.Tests/Generators/ConcretePolicyGenerator.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Threading;
+using FsCheck;
+using NBitcoin.Scripting.Miniscript;
+using NBitcoin.Scripting.Miniscript.Policy;
+
+namespace NBitcoin.Tests.Generators
+{
+	public class ConcretePolicyGenerator
+	{
+		public static Arbitrary<ConcretePolicy<PubKey, uint160>> PubKeyConcretePolicyArb()
+			=> new ArbitraryPubKeyConcretePolicy();
+
+		public class ArbitraryPubKeyConcretePolicy : Arbitrary<ConcretePolicy<PubKey, uint160>>
+		{
+			public override Gen<ConcretePolicy<PubKey, uint160>> Generator => Gen.Sized(ConcretePolicyGen);
+
+			/*
+			public override IEnumerable<ConcretePolicy<PubKey, uint160>> Shrinker(ConcretePolicy<PubKey, uint160> parent)
+			{
+				switch (parent)
+				{
+					case ConcretePolicy<PubKey, uint160>.And p:
+						foreach (var i in p.Item)
+							yield return i;
+						foreach (var i in Arb.Shrink(p.Item))
+							if (i.Count == 2)
+								yield return ConcretePolicy<PubKey, uint160>.NewAnd(i);
+						break;
+					case ConcretePolicy<PubKey, uint160>.Or p:
+						foreach (var i in p.Item)
+							yield return i.Item2;
+						foreach (var i in Arb.Shrink(p.Item))
+							if (i.Count == 2)
+								yield return ConcretePolicy<PubKey, uint160>.NewOr(i);
+						break;
+					case ConcretePolicy<PubKey, uint160>.Threshold p:
+						foreach (var subP in p.Item2)
+						{
+							yield return subP;
+						}
+						foreach (var i in Arb.Shrink(p.Item2).Select(s => s.Select(sub => Shrinker(sub))))
+						{
+							foreach (var i2 in i)
+								if (1 < i2.Count())
+									yield return ConcretePolicy<PubKey, uint160>.NewThreshold(1, i2);
+						}
+
+						foreach (var subP in Arb.Shrink(p.Item2))
+						{
+							if (1 < subP.Count())
+								yield return ConcretePolicy<PubKey, uint160>.NewThreshold(1, subP);
+						}
+						yield break;
+				}
+			}
+			*/
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> ConcretePolicyGen(int size)
+			{
+				if (size == 0) return NonRecursivePolicyGen();
+				return Gen.Frequency(
+					Tuple.Create(3, NonRecursivePolicyGen()),
+					Tuple.Create(2, RecursivePolicyGen(size / 2))
+					);
+			}
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> NonRecursivePolicyGen()
+				=> Gen.OneOf(new[]
+				{
+					KeyGen(),
+					AfterGen(),
+					OlderGen(),
+					Sha256Gen(),
+					Hash256Gen(),
+					Ripemd160Gen(),
+					Hash160Gen()
+				});
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> KeyGen()
+				=>
+					from inner in CryptoGenerator.PublicKey()
+					select ConcretePolicy<PubKey, uint160>.NewKey(inner);
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> AfterGen()
+				=>
+					from t in Arb.Generate<PositiveInt>()
+					select ConcretePolicy<PubKey, uint160>.NewAfter((uint)t.Get);
+			private static Gen<ConcretePolicy<PubKey, uint160>> OlderGen()
+				=>
+					from t in Arb.Generate<PositiveInt>()
+					select ConcretePolicy<PubKey, uint160>.NewOlder((uint)t.Get);
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> Sha256Gen()
+				=>
+					from t in CryptoGenerator.Hash256()
+					select ConcretePolicy<PubKey, uint160>.NewSha256(t);
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> Hash256Gen()
+				=>
+					from t in CryptoGenerator.Hash256()
+					select ConcretePolicy<PubKey, uint160>.NewHash256(t);
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> Ripemd160Gen()
+				=>
+					from t in CryptoGenerator.Hash160()
+					select ConcretePolicy<PubKey, uint160>.NewRipemd160(t);
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> Hash160Gen()
+				=>
+					from t in CryptoGenerator.Hash160()
+					select ConcretePolicy<PubKey, uint160>.NewHash160(t);
+
+			private static Gen<ConcretePolicy<PubKey, uint160>> RecursivePolicyGen(int size)
+				=>
+					Gen.OneOf(
+					(from sub in ConcretePolicyGen(size).Two()
+					select ConcretePolicy<PubKey, uint160>.NewAnd(new[] {sub.Item1, sub.Item2})),
+					(from prob in Arb.Generate<PositiveInt>().Two()
+					from sub in ConcretePolicyGen(size).Two()
+					select ConcretePolicy<PubKey, uint160>.NewOr(
+						new []{
+						Tuple.Create((uint)prob.Item1.Get, sub.Item1),
+						Tuple.Create((uint)prob.Item2.Get, sub.Item2)
+						})),
+					(from t in ThresholdContentsGen(size)
+					select ConcretePolicy<PubKey, uint160>.NewThreshold(t.Item1, t.Item2))
+					);
+
+			private static Gen<Tuple<uint, ConcretePolicy<PubKey, uint160>[]>> ThresholdContentsGen(int size)
+				=>
+					from n in Gen.Choose(1, 6)
+					from actualN in n == 1 ? Gen.Choose(2, 6) : Gen.Choose(n, 6)
+					from a in Gen.ArrayOf(actualN, ConcretePolicyGen(size))
+					select Tuple.Create((uint) n, a);
+		}
+	}
+
+}

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());
-	}
-}
+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());
+	}
+}