fix: replace useless code by existing package

Author: Nezketsu

packages/r/greg007/TrustFactor/admin.gno

@@ -1,13 +1,17 @@
 package trustfactor
 
-import "strings"
+import (
+	"strings"
+
+	"gno.land/p/nt/ownable"
+)
 
 // =============================================================================
 // ADMIN FUNCTIONS (OWNER ONLY)
 // =============================================================================
 
 // RemoveUser removes a malicious user from the system (emergency function)
-func RemoveUser(target address) {
+func RemoveUser(cur realm, target address) {
 	owner.AssertOwnedByCurrent()
 
 	trustScores.Remove(string(target))
@@ -29,17 +33,7 @@ func RemoveUser(target address) {
 	invalidateCache()
 }
 
-// TransferOwnership transfers contract ownership to a new address
-func TransferOwnership(newOwner address) error {
-	return owner.TransferOwnership(newOwner)
-}
-
-// DropOwnership removes the owner, effectively disabling all admin functions
-func DropOwnership() error {
-	return owner.DropOwnershipByCurrent()
-}
-
-// Owner returns the current owner address
-func Owner() address {
-	return owner.Owner()
+// GetOwnable returns the ownable object for ownership management
+func GetOwnable() *ownable.Ownable {
+	return owner
 }

packages/r/greg007/TrustFactor/cache.gno

@@ -1,6 +1,9 @@
 package trustfactor
 
-import "time"
+import (
+	"strings"
+	"time"
+)
 
 // =============================================================================
 // PERFORMANCE OPTIMIZATION - CACHING & SORTING
@@ -116,26 +119,7 @@ func FilterUsers(searchTerm string, limit int, offset int) ([]address, int) {
 
 // containsSubstring checks if a string contains a substring (case-sensitive)
 func containsSubstring(str, substr string) bool {
-	if len(substr) == 0 {
-		return true
-	}
-	if len(substr) > len(str) {
-		return false
-	}
-
-	for i := 0; i <= len(str)-len(substr); i++ {
-		match := true
-		for j := 0; j < len(substr); j++ {
-			if str[i+j] != substr[j] {
-				match = false
-				break
-			}
-		}
-		if match {
-			return true
-		}
-	}
-	return false
+	return strings.Index(str, substr) >= 0
 }
 
 // GetPerformanceStats returns cache and performance statistics

packages/r/greg007/TrustFactor/comments.gno

@@ -2,7 +2,6 @@ package trustfactor
 
 import (
 	"time"
-
 	"chain/runtime"
 
 	"gno.land/p/nt/avl"
@@ -64,7 +63,7 @@ func GetComments(target address) []Comment {
 	tree := treeValue.(*avl.Tree)
 
 	comments := make([]Comment, 0)
-	tree.ReverseIterate("", "", func(key string, value interface{}) bool {
+	tree.ReverseIterate("", "", func(key string, value any) bool {
 		if comment, ok := value.(Comment); ok {
 			comments = append(comments, comment)
 		}

packages/r/greg007/TrustFactor/getters.gno

@@ -37,14 +37,9 @@ func GetTrustDetails(addr address) TrustScore {
 // DATA ACCESS FUNCTIONS
 // =============================================================================
 
-// GetAllUsers returns the complete trust scores map (used internally)
-func GetAllUsers() map[address]TrustScore {
-	result := make(map[address]TrustScore)
-	trustScores.Iterate("", "", func(key string, value interface{}) bool {
-		result[address(key)] = *value.(*TrustScore)
-		return false
-	})
-	return result
+// GetTotalUsers returns the total number of registered users
+func GetTotalUsers() int {
+	return totalUsers
 }
 
 // GetVoteHistory returns the voting history for a specific user

packages/r/greg007/TrustFactor/render.gno

@@ -2,7 +2,6 @@ package trustfactor
 
 import (
 	"strconv"
-	"strings"
 
 	"gno.land/p/leon/svgbtn"
 	"gno.land/p/moul/md"
@@ -44,8 +43,9 @@ func renderMainPageWithFilter(filter string) string {
 	}) + "\n"
 
 	var topUsers []address
-	allUsers := GetAllUsers()
-	for addr, trust := range allUsers {
+	sortedUsers := GetSortedUsers()
+	for _, addr := range sortedUsers {
+		trust := GetTrustDetails(addr)
 		if trust.TotalVotes >= 3 {
 			topUsers = append(topUsers, addr)
 			if len(topUsers) >= 5 {
@@ -238,19 +238,14 @@ func renderSearchResults(query string) string {
 	}
 
 	addr := address(query)
-	if _, exists := GetAllUsers()[addr]; exists {
+	if _, exists := trustScores.Get(string(addr)); exists {
 		return renderUserProfile(string(addr))
 	}
 
 	result := md.H1("🔍 Search results for: " + md.InlineCode(query))
 
-	var matches []address
-	for addr := range GetAllUsers() {
-		addrStr := string(addr)
-		if len(query) >= 4 && strings.Contains(addrStr, query) {
-			matches = append(matches, addr)
-		}
-	}
+	// Use FilterUsers to get matches (already sorted by score)
+	matches, _ := FilterUsers(query, 100, 0) // Get up to 100 matches
 
 	matchCount := len(matches)
 

packages/r/greg007/TrustFactor/trustfactor_test.gno

@@ -470,9 +470,10 @@ func TestScoreBounds(t *testing.T) {
 	}
 }
 
-// TestGetAllUsers tests retrieving all registered users
-func TestGetAllUsers(t *testing.T) {
+// TestGetTotalUsers tests retrieving total user count
+func TestGetTotalUsers(t *testing.T) {
 	trustScores = avl.NewTree()
+	totalUsers = 0
 
 	addr1 := address("g1user1234567890123456789012345678")
 	addr2 := address("g1user2345678901234567890123456789")
@@ -481,23 +482,25 @@ func TestGetAllUsers(t *testing.T) {
 	trustScores.Set(string(addr1), &TrustScore{Score: 5.0, LastUpdate: time.Now().Unix()})
 	trustScores.Set(string(addr2), &TrustScore{Score: 6.0, LastUpdate: time.Now().Unix()})
 	trustScores.Set(string(addr3), &TrustScore{Score: 7.0, LastUpdate: time.Now().Unix()})
+	totalUsers = 3
 
-	allUsers := GetAllUsers()
+	count := GetTotalUsers()
 
-	if len(allUsers) != 3 {
-		t.Errorf("Expected 3 users, got %d", len(allUsers))
+	if count != 3 {
+		t.Errorf("Expected 3 users, got %d", count)
 	}
 
-	if _, exists := allUsers[addr1]; !exists {
-		t.Error("addr1 should exist in all users")
+	// Verify users exist using GetTrustDetails
+	if trust := GetTrustDetails(addr1); trust.Score == 0 {
+		t.Error("addr1 should exist")
 	}
 
-	if _, exists := allUsers[addr2]; !exists {
-		t.Error("addr2 should exist in all users")
+	if trust := GetTrustDetails(addr2); trust.Score == 0 {
+		t.Error("addr2 should exist")
 	}
 
-	if _, exists := allUsers[addr3]; !exists {
-		t.Error("addr3 should exist in all users")
+	if trust := GetTrustDetails(addr3); trust.Score == 0 {
+		t.Error("addr3 should exist")
 	}
 }