refactor: replace sort.Slice with slices.Sort for natural ordering

[dulanting]

Changelist

[Describe or list the changes made in this PR]

There is a new function added in the go1.21 standard library, which can make the code more concise and easy to read.

Test Plan

[Describe how this PR was tested (if applicable)]

Author/Reviewer Checklist

• If this PR has changes that result in a different app state given the same prior state and transaction list, manually add the state-breaking label.
• If the PR has breaking postgres changes to the indexer add the indexer-postgres-breaking label.
• If this PR isn't state-breaking but has changes that modify behavior in PrepareProposal or ProcessProposal, manually add the label proposal-breaking.
• If this PR is one of many that implement a specific feature, manually label them all feature:[feature-name].
• If you wish to for mergify-bot to automatically create a PR to backport your change to a release branch, manually add the label backport/[branch-name].
• Manually add any of the following labels: refactor, chore, bug.

Summary by CodeRabbit

• Refactor
  • Modernized internal sorting logic across math utilities, perpetuals processing, and pricing client helpers to use standardized library routines.
  • Improves readability and maintainability while aligning with current language best practices.
  • No changes to public APIs, configuration, or user-facing behavior; result ordering remains identical.
  • Minor internal cleanup only; functionality, outputs, and error handling are unchanged.

[coderabbitai]

Walkthrough

Replaced usages of sort.Slice with slices.Sort across three Go files, updating imports accordingly. No function signatures, external behavior, or error handling changed. Control flow remains the same aside from the sorting method.

Changes

Cohort / File(s)	Summary
Sorting API update protocol/lib/math.go, protocol/x/perpetuals/keeper/perpetual.go, protocol/x/prices/client/testutil/util.go	Switched from sort.Slice to slices.Sort for ordering slices; updated imports from "sort" to "slices". No public API or logic changes beyond the sorting call substitution.

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~10 minutes

Poem

I twitch my nose at tidy code,
Re-sorted trails on the data road.
From Slice to slices—swift and neat,
A cleaner hop on sorted feet.
Thump-thump! My ears applaud the art—
Small change, but sweetly done, dear heart. 🐇✨

Pre-merge checks and finishing touches

❌ Failed checks (2 warnings)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 50.00% which is insufficient. The required threshold is 80.00%.	You can run @coderabbitai generate docstrings to improve docstring coverage.
Description Check	⚠️ Warning	The PR description includes the required section headings but the Changelist and Test Plan sections remain as placeholders without actual change details or testing information, so the template is incomplete.	Please replace the placeholder text in the Changelist with a detailed list of the code changes and populate the Test Plan with how the changes were verified, ensuring each required template section is fully completed.

✅ Passed checks (1 passed)

Check name	Status	Explanation
Title Check	✅ Passed	The title succinctly and accurately describes the primary change in this PR by indicating the replacement of sort.Slice with slices.Sort for natural ordering and uses a standard “refactor:” prefix, making it clear and specific enough for teammates to understand the main intent without extraneous detail.

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[coderabbitai]

Actionable comments posted: 0

🧹 Nitpick comments (1)

protocol/x/perpetuals/keeper/perpetual.go (1)

619-619: LGTM!

The refactoring correctly replaces sort.Slice with slices.Sort for natural ascending order of []int32.

Consider completing the refactoring at lines 251-253 where sort.Slice is still used:

-	sort.Slice(list, func(i, j int) bool {
-		return list[i].Params.Id < list[j].Params.Id
-	})
+	slices.SortFunc(list, func(a, b types.Perpetual) int {
+		return int(a.Params.Id) - int(b.Params.Id)
+	})

Note: This would require slices.SortFunc since we're sorting by a field, not the struct itself.

📜 Review details

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 8eb3563 and 4797e87.

📒 Files selected for processing (3)

• protocol/lib/math.go (2 hunks)
• protocol/x/perpetuals/keeper/perpetual.go (2 hunks)
• protocol/x/prices/client/testutil/util.go (2 hunks)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (1)

• GitHub Check: Summary

🔇 Additional comments (5)

protocol/x/perpetuals/keeper/perpetual.go (1)

7-8: LGTM!

Both imports are needed: slices for the new Line 619 usage, and sort for the existing Line 251 usage.

protocol/lib/math.go (2)

8-8: LGTM!

The import change is appropriate since slices.Sort replaces the previous sort.Slice usage.

---

185-185: LGTM!

The refactoring correctly uses slices.Sort with the generic ordered constraint. All types in the constraint (uint64 | uint32 | int64 | int32) support natural ordering.

protocol/x/prices/client/testutil/util.go (2)

4-4: LGTM!

The import change is appropriate for the new slices.Sort usage.

---

15-15: LGTM!

The refactoring correctly uses slices.Sort for natural ascending order of []uint32.