Fix additional deadlocks in handlers_devfund, handlers_friends, handlers_items, and handlers_keys

- Fix deadlocks in escrowTransfer and escrowRelease (handlers_devfund.go)
- Fix deadlock in rejectFriendRequest (handlers_friends.go)
- Fix deadlock in buyItem (handlers_items.go)
- Fix deadlock in checkSubscriptions (handlers_keys.go)
- All fixes use direct access methods while holding usersMutex to avoid nested locking

Co-authored-by: Mistium <92952823+Mistium@users.noreply.github.com>

Author: Copilot

handlers_devfund.go

@@ -53,19 +53,22 @@ func escrowTransfer(c *gin.Context) {
 		}
 	}
 	if fromUser == nil {
+		usersMutex.Unlock()
 		c.JSON(404, gin.H{"error": "Sender user not found"})
 		return
 	}
 
 	// Check sender balance
 	fromCurrency := fromUser.GetCredits()
 	if fromCurrency == 0 {
+		usersMutex.Unlock()
 		c.JSON(400, gin.H{"error": "Sender user has no currency"})
 		return
 	}
 	fromCurrency = roundVal(fromCurrency)
 
 	if fromCurrency < nAmount {
+		usersMutex.Unlock()
 		c.JSON(400, gin.H{"error": "Insufficient funds", "required": nAmount, "available": fromCurrency})
 		return
 	}
@@ -75,12 +78,9 @@ func escrowTransfer(c *gin.Context) {
 	if newBal < 0 { // guard against tiny floating error
 		newBal = 0
 	}
-	usersMutex.Unlock()
-
-	fromUser.SetBalance(newBal)
-
-	usersMutex.Lock()
-	defer usersMutex.Unlock()
+	
+	// Update balance directly while holding lock
+	setUserKeyDirect(fromUser, "sys.currency", roundVal(newBal))
 
 	// Add escrow transaction to sender
 	now := time.Now().UnixMilli()
@@ -92,15 +92,27 @@ func escrowTransfer(c *gin.Context) {
 		note = note[:50]
 	}
 
-	fromUser.addTransaction(map[string]any{
+	// Add transaction directly while holding lock
+	txs := getObjectSlice(*fromUser, "sys.transactions")
+	benefits := fromUser.GetSubscriptionBenefits()
+	
+	tx := map[string]any{
 		"note":        note,
 		"user":        "devfund-escrow",
 		"time":        now,
 		"amount":      nAmount,
 		"type":        "escrow_out",
 		"petition_id": req.PetitionID,
 		"new_total":   newBal,
-	})
+	}
+	
+	txs = append([]map[string]any{tx}, txs...)
+	if len(txs) > benefits.Max_Transaction_History {
+		txs = txs[:benefits.Max_Transaction_History]
+	}
+	setUserKeyDirect(fromUser, "sys.transactions", txs)
+	
+	usersMutex.Unlock()
 
 	go saveUsers()
 
@@ -164,24 +176,20 @@ func escrowRelease(c *gin.Context) {
 		}
 	}
 	if toUser == nil {
+		usersMutex.Unlock()
 		c.JSON(404, gin.H{"error": "Recipient user not found"})
 		return
 	}
 
-	usersMutex.Unlock()
 	// Get recipient balance
 	toCurrency := toUser.GetCredits()
 	if toCurrency == 0 {
-		toUser.SetBalance(float64(0))
 		toCurrency = float64(0)
 	}
 
 	// Add credits to recipient
 	newBal := roundVal(toCurrency + nAmount)
-	toUser.SetBalance(newBal)
-
-	usersMutex.Lock()
-	defer usersMutex.Unlock()
+	setUserKeyDirect(toUser, "sys.currency", newBal)
 
 	// Add transaction to recipient
 	now := time.Now().UnixMilli()
@@ -193,16 +201,27 @@ func escrowRelease(c *gin.Context) {
 		note = note[:50]
 	}
 
-	// Helper to add transaction
-	toUser.addTransaction(map[string]any{
+	// Add transaction directly while holding lock
+	txs := getObjectSlice(*toUser, "sys.transactions")
+	benefits := toUser.GetSubscriptionBenefits()
+	
+	tx := map[string]any{
 		"note":        note,
 		"user":        "devfund-escrow",
 		"time":        now,
 		"amount":      nAmount,
 		"type":        "escrow_in",
 		"petition_id": req.PetitionID,
 		"new_total":   newBal,
-	})
+	}
+	
+	txs = append([]map[string]any{tx}, txs...)
+	if len(txs) > benefits.Max_Transaction_History {
+		txs = txs[:benefits.Max_Transaction_History]
+	}
+	setUserKeyDirect(toUser, "sys.transactions", txs)
+
+	usersMutex.Unlock()
 
 	go saveUsers()
 

handlers_friends.go

@@ -152,7 +152,8 @@ func rejectFriendRequest(c *gin.Context) {
 
 	usersMutex.Lock()
 
-	currentRequests := getStringSlice(*current, "sys.requests")
+	// Use direct access since we hold usersMutex
+	currentRequests := getStringSliceDirect(*current, "sys.requests")
 	found := false
 	newRequests := make([]string, 0, len(currentRequests))
 	for _, r := range currentRequests {

handlers_items.go

@@ -159,7 +159,8 @@ func buyItem(c *gin.Context) {
 		c.JSON(404, gin.H{"error": "User not found"})
 		return
 	}
-	users[userIndex].SetBalance(userCurrency - float64(targetItem.Price))
+	// Use direct access since we hold usersMutex
+	setUserKeyDirect(&users[userIndex], "sys.currency", roundVal(userCurrency-float64(targetItem.Price)))
 	go saveUsers()
 
 	// Notify both users

handlers_keys.go

@@ -640,31 +640,51 @@ func checkSubscriptions() {
 						}
 						currencyFloat -= float64(userData.Price)
 						usersMutex.Lock()
-						purchaser.SetBalance(currencyFloat)
-						purchaser.addTransaction(map[string]any{
+						// Use direct access since we hold usersMutex
+						setUserKeyDirect(&users[userIndex], "sys.currency", roundVal(currencyFloat))
+						
+						// Add transaction directly
+						txs := getObjectSlice(users[userIndex], "sys.transactions")
+						benefits := users[userIndex].GetSubscriptionBenefits()
+						tx := map[string]any{
 							"note":      "key purchase",
 							"key_id":    key.Key,
 							"key_name":  key.Name,
 							"user":      key.Creator,
 							"amount":    float64(userData.Price),
 							"type":      "key_buy",
 							"new_total": currencyFloat,
-						})
+						}
+						txs = append([]map[string]any{tx}, txs...)
+						if len(txs) > benefits.Max_Transaction_History {
+							txs = txs[:benefits.Max_Transaction_History]
+						}
+						setUserKeyDirect(&users[userIndex], "sys.transactions", txs)
 
 						// 10% tax on purchase
 						value := float64(userData.Price) * 0.9
 						owner := users[ownerIndex]
 						newBal := owner.GetCredits() + value
-						owner.SetBalance(newBal)
-						owner.addTransaction(map[string]any{
+						setUserKeyDirect(&users[ownerIndex], "sys.currency", roundVal(newBal))
+						
+						// Add transaction for owner
+						ownerTxs := getObjectSlice(owner, "sys.transactions")
+						ownerBenefits := owner.GetSubscriptionBenefits()
+						ownerTx := map[string]any{
 							"note":      "key purchase",
 							"key_id":    key.Key,
 							"key_name":  key.Name,
 							"user":      username,
 							"amount":    float64(userData.Price),
 							"type":      "key_sale",
 							"new_total": newBal,
-						})
+						}
+						ownerTxs = append([]map[string]any{ownerTx}, ownerTxs...)
+						if len(ownerTxs) > ownerBenefits.Max_Transaction_History {
+							ownerTxs = ownerTxs[:ownerBenefits.Max_Transaction_History]
+						}
+						setUserKeyDirect(&users[ownerIndex], "sys.transactions", ownerTxs)
+						
 						usersMutex.Unlock()
 						go saveUsers()