tapgarden: use atomic counter in MockKeyRing and relax test checks

Introduce an atomic counter `deriveNextKeyCallCount` in `MockKeyRing` to
track calls to `DeriveNextKey` without relying on the internal mock
mutex. This allows tests to query and reset the count directly in a
thread-safe way.

Update `queueSeedlingsInBatch` to:
* replace `require.Eventually` with `wait.NoError`, so failures log the
  actual state for easier debugging,
* relax the check from strict equality to `>=` expected, tolerating
  extra key derivations and reducing flakiness.

Author: ffranr

tapgarden/mock.go

@@ -857,6 +857,10 @@ type MockKeyRing struct {
 	KeyIndex uint32
 
 	Keys map[keychain.KeyLocator]*btcec.PrivateKey
+
+	// deriveNextKeyCallCount is used to track the number of calls to
+	// DeriveNextKey.
+	deriveNextKeyCallCount atomic.Uint64
 }
 
 var _ KeyRing = (*MockKeyRing)(nil)
@@ -899,6 +903,7 @@ func (m *MockKeyRing) DeriveNextKey(ctx context.Context,
 	}()
 
 	m.Called(ctx, keyFam)
+	m.deriveNextKeyCallCount.Add(1)
 
 	select {
 	case <-ctx.Done():
@@ -1007,6 +1012,19 @@ func (m *MockKeyRing) DeriveSharedKey(_ context.Context, key *btcec.PublicKey,
 	return ecdh.ECDH(key)
 }
 
+// DeriveNextKeyCallCount returns the number of calls to DeriveNextKey. This is
+// useful in tests to assert that the key ring was used as expected in
+// concurrent scenarios.
+func (m *MockKeyRing) DeriveNextKeyCallCount() int {
+	return int(m.deriveNextKeyCallCount.Load())
+}
+
+// ResetDeriveNextKeyCallCount resets the call counter for DeriveNextKey to
+// zero. This is useful in tests to ensure a clean state for assertions.
+func (m *MockKeyRing) ResetDeriveNextKeyCallCount() {
+	m.deriveNextKeyCallCount.Store(0)
+}
+
 type MockGenSigner struct {
 	KeyRing     *MockKeyRing
 	failSigning atomic.Bool

tapgarden/planter_test.go

@@ -272,8 +272,9 @@ func (t *mintingTestHarness) queueSeedlingsInBatch(isFunded bool,
 
 	for i, seedling := range seedlings {
 		seedling := seedling
+
+		t.keyRing.ResetDeriveNextKeyCallCount()
 		keyCount := 0
-		t.keyRing.Calls = nil
 
 		// For the first seedling sent, we should get a new request,
 		// representing the batch internal key.
@@ -310,18 +311,21 @@ func (t *mintingTestHarness) queueSeedlingsInBatch(isFunded bool,
 		// The received update should be a state of MintingStateSeed.
 		require.Equal(t, tapgarden.MintingStateSeed, update.NewState)
 
-		require.Eventually(t, func() bool {
+		err = wait.NoError(func() error {
 			// Assert that the key ring method DeriveNextKey was
 			// called the expected number of times.
-			count := 0
-			for _, call := range t.keyRing.Calls {
-				if call.Method == "DeriveNextKey" {
-					count++
-				}
+			expectedCount := keyCount
+			actualCount := t.keyRing.DeriveNextKeyCallCount()
+
+			if actualCount < expectedCount {
+				return fmt.Errorf("expected %d calls to key "+
+					"derivation, got %d", expectedCount,
+					actualCount)
 			}
 
-			return count == keyCount
-		}, defaultTimeout, wait.PollInterval)
+			return nil
+		}, defaultTimeout)
+		require.NoError(t, err)
 	}
 }