Coin selection improvement

WalletWasabi.Tests/UnitTests/LinqExtensionsTests.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Linq;
 using WalletWasabi.Extensions;
 using Xunit;
@@ -107,4 +108,18 @@ public void MaxOrDefault()
 		Assert.Equal(4, new int[] { 4, 3 }.MaxOrDefault(defaultValue: 10));
 		Assert.Equal(4, new int[] { 4 }.MaxOrDefault(defaultValue: 10));
 	}
+
+	[Fact]
+	public void GeneralizedWeightedMean()
+	{
+		List<(double, double)> values = new() { (1.0, 1.1), (1.2, 1.3) };
+		Assert.Equal(1.097412680210462, values.GeneralizedWeightedMean(x => x.Item1, x => x.Item2, -1.4));
+	}
+
+	[Fact]
+	public void GeneralizedWeightedMeanOneP()
+	{
+		List<(double, double)> values = new() { (1.0, 1.1), (1.2, 1.3) };
+		Assert.Equal(values.WeightedMean(x => x.Item1, x => x.Item2), values.GeneralizedWeightedMean(x => x.Item1, x => x.Item2, 1.0));
+	}
 }

WalletWasabi.Tests/UnitTests/WabiSabi/Client/CoinJoinCoinSelectionTests.cs

@@ -151,6 +151,35 @@ public void SelectTwoNonPrivateCoinsFromTwoCoinsSetOfCoinsConsolidationMode()
 		Assert.Equal(2, coins.Count);
 	}
 
+	[Fact]
+	public void DoNotSelectCoinsWithBigAnonymityLoss()
+	{
+		// This test ensures that we do not select coins whose anonymity could be lowered a lot.
+		const int AnonymitySet = 10;
+		var km = KeyManager.CreateNew(out _, "", Network.Main);
+		var bigCoinWithSmallAnonymity1 = BitcoinFactory.CreateSmartCoin(BitcoinFactory.CreateHdPubKey(km), Money.Coins(1m), anonymitySet: 1);
+		var bigCoinWithSmallAnonymity2 = BitcoinFactory.CreateSmartCoin(BitcoinFactory.CreateHdPubKey(km), Money.Coins(1m), anonymitySet: 2);
+		var smallCoinWithBigAnonymity = BitcoinFactory.CreateSmartCoin(BitcoinFactory.CreateHdPubKey(km), Money.Coins(0.1m), anonymitySet: 6);
+		var coinsToSelectFrom = Enumerable
+			.Empty<SmartCoin>()
+			.Append(bigCoinWithSmallAnonymity1)
+			.Append(bigCoinWithSmallAnonymity2)
+			.Append(smallCoinWithBigAnonymity)
+			.ToList();
+
+		var coins = CoinJoinClient.SelectCoinsForRound(
+			coins: coinsToSelectFrom,
+			UtxoSelectionParameters.FromRoundParameters(CreateMultipartyTransactionParameters()),
+			consolidationMode: true,
+			anonScoreTarget: AnonymitySet,
+			semiPrivateThreshold: 0,
+			liquidityClue: Money.Coins(0.5m),
+			ConfigureRng(1));
+
+		Assert.False(coins.Contains(bigCoinWithSmallAnonymity1) && coins.Contains(smallCoinWithBigAnonymity));
+		Assert.False(coins.Contains(bigCoinWithSmallAnonymity2) && coins.Contains(smallCoinWithBigAnonymity));
+	}
+
 	private static WasabiRandom ConfigureRng(int returnValue)
 	{
 		var mockWasabiRandom = new Mock<WasabiRandom>();

WalletWasabi/Blockchain/Analysis/BlockchainAnalyzer.cs

@@ -69,8 +69,8 @@ private static void AnalyzeCoinjoinWalletInputs(SmartTransaction tx, out double
 		// Consolidation in coinjoins is the only type of consolidation that's acceptable,
 		// because coinjoins are an exception from common input ownership heuristic.
 		// Calculate weighted average.
-		mixedAnonScore = CoinjoinAnalyzer.WeightedAverage(tx.WalletVirtualInputs.Select(x => new CoinjoinAnalyzer.AmountWithAnonymity(x.HdPubKey.AnonymitySet, x.Amount)));
-		mixedAnonScoreSanctioned = CoinjoinAnalyzer.WeightedAverage(tx.WalletVirtualInputs.Select(x => new CoinjoinAnalyzer.AmountWithAnonymity(x.HdPubKey.AnonymitySet + cjAnal.ComputeInputSanction(x, CoinjoinAnalyzer.WeightedAverage), x.Amount)));
+		mixedAnonScore = CoinjoinAnalyzer.WeightedMean(tx.WalletVirtualInputs.Select(x => new CoinjoinAnalyzer.AmountWithAnonymity(x.HdPubKey.AnonymitySet, x.Amount)));
+		mixedAnonScoreSanctioned = CoinjoinAnalyzer.WeightedMean(tx.WalletVirtualInputs.Select(x => new CoinjoinAnalyzer.AmountWithAnonymity(x.HdPubKey.AnonymitySet + cjAnal.ComputeInputSanction(x, CoinjoinAnalyzer.WeightedMean), x.Amount)));
 
 		nonMixedAnonScore = CoinjoinAnalyzer.Min(tx.WalletVirtualInputs.Select(x => new CoinjoinAnalyzer.AmountWithAnonymity(x.HdPubKey.AnonymitySet, x.Amount)));
 		nonMixedAnonScoreSanctioned = CoinjoinAnalyzer.Min(tx.WalletVirtualInputs.Select(x => new CoinjoinAnalyzer.AmountWithAnonymity(x.HdPubKey.AnonymitySet + cjAnal.ComputeInputSanction(x, CoinjoinAnalyzer.Min), x.Amount)));

WalletWasabi/Blockchain/Analysis/CoinjoinAnalyzer.cs

@@ -11,7 +11,7 @@ public class CoinjoinAnalyzer
 {
 	public static readonly int MaxRecursionDepth = 3;
 	public static readonly AggregationFunction Min = x => x.Any() ? x.Min(x => x.Anonymity) : 0;
-	public static readonly AggregationFunction WeightedAverage = x => x.Any() ? x.WeightedAverage(x => x.Anonymity, x => x.Amount.Satoshi) : 0;
+	public static readonly AggregationFunction WeightedMean = x => x.Any() ? x.WeightedMean(x => x.Anonymity, x => x.Amount.Satoshi) : 0;
 
 	public CoinjoinAnalyzer(SmartTransaction transaction)
 	{

WalletWasabi/Extensions/LinqExtensions.cs

@@ -209,11 +209,48 @@ public static IEnumerable<T> TakeUntil<T>(this IEnumerable<T> list, Func<T, bool
 		}
 	}
 
-	public static double WeightedAverage<T>(this IEnumerable<T> source, Func<T, double> value, Func<T, double> weight)
+	public static double WeightedMean<T>(this IEnumerable<T> source, Func<T, double> value, Func<T, double> weight)
 	{
 		return source.Select(x => value(x) * weight(x)).Sum() / source.Select(weight).Sum();
 	}
 
+	public static double GeneralizedWeightedMean<T>(this IEnumerable<T> source, Func<T, double> value, Func<T, double> weight, double p)
+	{
+		// See https://en.wikipedia.org/wiki/Generalized_mean
+		// Basic properties:
+		//   * GeneralizedWeightedAverage(source, value, weight, 1) = WeightedAverage(source, value, weight)
+		//   * GeneralizedWeightedAverage(source, value, weight, p) goes to Max(source, value) as p goes to the infinity
+		//   * GeneralizedWeightedAverage(source, value, weight, p) goes to Min(source, value) as p goes to the minus infinity
+		//   * GeneralizedWeightedAverage(source, value, weight, p) <= GeneralizedWeightedAverage(source, value, weight, q) provided p < q
+
+		if (!source.Any())
+		{
+			throw new ArgumentException("Cannot be empty.", nameof(source));
+		}
+
+		if (source.Any(x => value(x) < 0))
+		{
+			throw new ArgumentException("Cannot be negative.", nameof(value));
+		}
+
+		if (source.Any(x => weight(x) < 0))
+		{
+			throw new ArgumentException("Cannot be negative.", nameof(weight));
+		}
+
+		if (source.All(x => weight(x) == 0))
+		{
+			throw new ArgumentException("Cannot be all zero.", nameof(weight));
+		}
+
+		if (p == 0)
+		{
+			throw new ArgumentException("Cannot be zero.", nameof(p));
+		}
+
+		return Math.Pow(source.Select(x => Math.Pow(value(x), p) * weight(x)).Sum() / source.Select(weight).Sum(), 1 / p);
+	}
+
 	public static int MaxOrDefault(this IEnumerable<int> me, int defaultValue) =>
 		me.DefaultIfEmpty(defaultValue).Max();
 }

WalletWasabi/WabiSabi/Client/CoinJoinClient.cs

@@ -187,7 +187,7 @@ public async Task<CoinJoinResult> StartCoinJoinAsync(IEnumerable<SmartCoin> coin
 				case DisruptedCoinJoinResult info:
 					// Only use successfully registered coins in the blame round.
 					coins = info.SignedCoins;
-				
+
 					currentRoundState.LogInfo("Waiting for the blame round.");
 					currentRoundState = await WaitForBlameRoundAsync(currentRoundState.Id, cancellationToken).ConfigureAwait(false);
 					break;
@@ -197,7 +197,7 @@ public async Task<CoinJoinResult> StartCoinJoinAsync(IEnumerable<SmartCoin> coin
 
 				case FailedCoinJoinResult failure:
 					return failure;
-			
+
 				default:
 					throw new InvalidOperationException("The coinjoin result type was not handled.");
 			}
@@ -263,10 +263,10 @@ public async Task<CoinJoinResult> StartRoundAsync(IEnumerable<SmartCoin> smartCo
 				EndRoundState.None => "Unknown.",
 				_ => throw new ArgumentOutOfRangeException()
 			};
-			
+
 			roundState.LogInfo(msg);
 			var signedCoins = aliceClientsThatSigned.Select(a => a.SmartCoin).ToImmutableList();
-			
+
 			return roundState.EndRoundState switch
 			{
 				EndRoundState.TransactionBroadcasted => new SuccessfulCoinJoinResult(
@@ -530,7 +530,7 @@ internal static bool SanityCheck(IEnumerable<TxOut> expectedOutputs, IEnumerable
 					x => x.ScriptPubKey,
 					(coinjoinOutput, expectedOutput) => coinjoinOutput.Value - expectedOutput.Value)
 				.All(x => x >= 0L);
-		
+
 		return AllExpectedScriptsArePresent() && AllOutputsHaveAtLeastTheExpectedValue();
 	}
 
@@ -947,8 +947,17 @@ private void LogCoinJoinSummary(ImmutableArray<AliceClient> registeredAliceClien
 	private static double GetAnonLoss<TCoin>(IEnumerable<TCoin> coins)
 		where TCoin : ISmartCoin
 	{
+		if (coins.Count() <= 1)
+		{
+			return 0;
+		}
+
+		// Parameters were picked experimentally to model anonymity loss that matches real-world experience: https://github.com/zkSNACKs/WalletWasabi/pull/10096
+		double p = 10;
+		double q = 0.8;
+
 		double minimumAnonScore = coins.Min(x => x.AnonymitySet);
-		return coins.Sum(x => (x.AnonymitySet - minimumAnonScore) * x.Amount.Satoshi) / coins.Sum(x => x.Amount.Satoshi);
+		return coins.GeneralizedWeightedMean(value: x => x.AnonymitySet - minimumAnonScore, weight: x => Math.Pow(x.Amount.Satoshi, q), p);
 	}
 
 	private static int GetRandomBiasedSameTxAllowance(WasabiRandom rnd, int percent)