Fix balance fuzz tests (#3251)

Those tests started randomly failing after moving to anchor outputs.
The reason is that anchor outputs have a bigger commit weight than non
anchor channels, and with our initial balance allocation we sometimes
reached a point where the *remote* had exhausted all of its balance to
pay commit fees (when the feerate was around 10 000 sat/kw), so the
*local* couldn't send HTLCs (`RemoteCannotAffordFeesForNewHtlc`). This
is an expected situation where we cannot do anything except wait for
pending HTLCs to resolve before sending other HTLCs.

We simply increase the initial balance to avoid running into this case.
We also remove the `skip` case (which wasn't working at all, we should
have used the `cancel` scalatest helper if we wanted to interrupt the
test without failing it) and allow failures during the initial HTLC
setup (which can happen if HTLCs are larger than the available balance).

Author: t-bast

eclair-core/src/test/scala/fr/acinq/eclair/channel/CommitmentsSpec.scala

@@ -415,25 +415,25 @@ class CommitmentsSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike with
   }
 
   test("should always be able to send availableForSend", Tag("fuzzy")) { f =>
-    val maxPendingHtlcAmount = 1000000.msat
+    val maxPendingHtlcAmount = 1_000_000.msat
     case class FuzzTest(isInitiator: Boolean, pendingHtlcs: Int, feeRatePerKw: FeeratePerKw, dustLimit: Satoshi, toLocal: MilliSatoshi, toRemote: MilliSatoshi)
     for (_ <- 1 to 100) {
       val t = FuzzTest(
         isInitiator = Random.nextInt(2) == 0,
         pendingHtlcs = Random.nextInt(10),
-        feeRatePerKw = FeeratePerKw(Random.nextInt(10000).max(1).sat),
+        feeRatePerKw = FeeratePerKw(Random.nextInt(10_000).max(1).sat),
         dustLimit = Random.nextInt(1000).sat,
-        // We make sure both sides have enough to send/receive at least the initial pending HTLCs.
-        toLocal = maxPendingHtlcAmount * 2 * 10 + Random.nextInt(1000000000).msat,
-        toRemote = maxPendingHtlcAmount * 2 * 10 + Random.nextInt(1000000000).msat)
+        // We make sure both sides have enough to send/receive at least the initial pending HTLCs while paying the commit fees.
+        toLocal = maxPendingHtlcAmount * 2 * 15 + Random.nextInt(1_000_000_000).msat,
+        toRemote = maxPendingHtlcAmount * 2 * 15 + Random.nextInt(1_000_000_000).msat)
       var c = CommitmentsSpec.makeCommitments(t.toLocal, t.toRemote, t.feeRatePerKw, t.dustLimit, t.isInitiator)
       // Add some initial HTLCs to the pending list (bigger commit tx).
       for (_ <- 1 to t.pendingHtlcs) {
         val amount = Random.nextInt(maxPendingHtlcAmount.toLong.toInt).msat.max(1 msat)
         val (_, cmdAdd) = makeCmdAdd(amount, randomKey().publicKey, f.currentBlockHeight)
         c.sendAdd(cmdAdd, f.currentBlockHeight, TestConstants.Alice.nodeParams.channelConf, feeConfNoMismatch) match {
           case Right((cc, _)) => c = cc
-          case Left(e) => ignore(s"$t -> could not setup initial htlcs: $e")
+          case Left(e) => // we ignore failures (the HTLC amount probably exceeded availableBalanceForSend)
         }
       }
       if (c.availableBalanceForSend > 0.msat) {
@@ -445,25 +445,25 @@ class CommitmentsSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike with
   }
 
   test("should always be able to receive availableForReceive", Tag("fuzzy")) { f =>
-    val maxPendingHtlcAmount = 1000000.msat
+    val maxPendingHtlcAmount = 1_000_000.msat
     case class FuzzTest(isInitiator: Boolean, pendingHtlcs: Int, feeRatePerKw: FeeratePerKw, dustLimit: Satoshi, toLocal: MilliSatoshi, toRemote: MilliSatoshi)
     for (_ <- 1 to 100) {
       val t = FuzzTest(
         isInitiator = Random.nextInt(2) == 0,
         pendingHtlcs = Random.nextInt(10),
-        feeRatePerKw = FeeratePerKw(Random.nextInt(10000).max(1).sat),
+        feeRatePerKw = FeeratePerKw(Random.nextInt(10_000).max(1).sat),
         dustLimit = Random.nextInt(1000).sat,
-        // We make sure both sides have enough to send/receive at least the initial pending HTLCs.
-        toLocal = maxPendingHtlcAmount * 2 * 10 + Random.nextInt(1000000000).msat,
-        toRemote = maxPendingHtlcAmount * 2 * 10 + Random.nextInt(1000000000).msat)
+        // We make sure both sides have enough to send/receive at least the initial pending HTLCs while paying the commit fees.
+        toLocal = maxPendingHtlcAmount * 2 * 15 + Random.nextInt(1_000_000_000).msat,
+        toRemote = maxPendingHtlcAmount * 2 * 15 + Random.nextInt(1_000_000_000).msat)
       var c = CommitmentsSpec.makeCommitments(t.toLocal, t.toRemote, t.feeRatePerKw, t.dustLimit, t.isInitiator)
       // Add some initial HTLCs to the pending list (bigger commit tx).
       for (_ <- 1 to t.pendingHtlcs) {
         val amount = Random.nextInt(maxPendingHtlcAmount.toLong.toInt).msat.max(1 msat)
         val add = UpdateAddHtlc(randomBytes32(), c.changes.remoteNextHtlcId, amount, randomBytes32(), CltvExpiry(f.currentBlockHeight), TestConstants.emptyOnionPacket, None, accountable = false, None)
         c.receiveAdd(add) match {
           case Right(cc) => c = cc
-          case Left(e) => ignore(s"$t -> could not setup initial htlcs: $e")
+          case Left(e) => // we ignore failures (the HTLC amount probably exceeded availableBalanceForReceive)
         }
       }
       if (c.availableBalanceForReceive > 0.msat) {