diff --git a/accounts/keystore/account_cache.go b/accounts/keystore/account_cache.go
index a88b0fa5f3..4ed1439514 100644
--- a/accounts/keystore/account_cache.go
+++ b/accounts/keystore/account_cache.go
@@ -40,8 +40,8 @@ import (
 const minReloadInterval = 2 * time.Second
 
 // byURL defines the sorting order for accounts.
-func byURL(a, b accounts.Account) bool {
-	return a.URL.Cmp(b.URL) < 0
+func byURL(a, b accounts.Account) int {
+	return a.URL.Cmp(b.URL)
 }
 
 // AmbiguousAddrError is returned when attempting to unlock
diff --git a/cmd/devp2p/dns_route53.go b/cmd/devp2p/dns_route53.go
index eae6f70f58..21a32f9414 100644
--- a/cmd/devp2p/dns_route53.go
+++ b/cmd/devp2p/dns_route53.go
@@ -288,11 +288,17 @@ func makeDeletionChanges(records map[string]recordSet, keep map[string]string) [
 // sortChanges ensures DNS changes are in leaf-added -> root-changed -> leaf-deleted order.
 func sortChanges(changes []types.Change) {
 	score := map[string]int{"CREATE": 1, "UPSERT": 2, "DELETE": 3}
-	slices.SortFunc(changes, func(a, b types.Change) bool {
+	slices.SortFunc(changes, func(a, b types.Change) int {
 		if a.Action == b.Action {
-			return *a.ResourceRecordSet.Name < *b.ResourceRecordSet.Name
+			return strings.Compare(*a.ResourceRecordSet.Name, *b.ResourceRecordSet.Name)
 		}
-		return score[string(a.Action)] < score[string(b.Action)]
+		if score[string(a.Action)] < score[string(b.Action)] {
+			return -1
+		}
+		if score[string(a.Action)] > score[string(b.Action)] {
+			return 1
+		}
+		return 0
 	})
 }
 
diff --git a/cmd/devp2p/nodeset.go b/cmd/devp2p/nodeset.go
index c040c1a908..7360dc5bcf 100644
--- a/cmd/devp2p/nodeset.go
+++ b/cmd/devp2p/nodeset.go
@@ -77,8 +77,8 @@ func (ns nodeSet) nodes() []*enode.Node {
 		result = append(result, n.N)
 	}
 	// Sort by ID.
-	slices.SortFunc(result, func(a, b *enode.Node) bool {
-		return bytes.Compare(a.ID().Bytes(), b.ID().Bytes()) < 0
+	slices.SortFunc(result, func(a, b *enode.Node) int {
+		return bytes.Compare(a.ID().Bytes(), b.ID().Bytes())
 	})
 	return result
 }
@@ -103,8 +103,14 @@ func (ns nodeSet) topN(n int) nodeSet {
 	for _, v := range ns {
 		byscore = append(byscore, v)
 	}
-	slices.SortFunc(byscore, func(a, b nodeJSON) bool {
-		return a.Score >= b.Score
+	slices.SortFunc(byscore, func(a, b nodeJSON) int {
+		if a.Score > b.Score {
+			return -1
+		}
+		if a.Score < b.Score {
+			return 1
+		}
+		return 0
 	})
 	result := make(nodeSet, n)
 	for _, v := range byscore[:n] {
diff --git a/common/types.go b/common/types.go
index 93fb090454..bf74e43716 100644
--- a/common/types.go
+++ b/common/types.go
@@ -65,9 +65,9 @@ func BigToHash(b *big.Int) Hash { return BytesToHash(b.Bytes()) }
 // If b is larger than len(h), b will be cropped from the left.
 func HexToHash(s string) Hash { return BytesToHash(FromHex(s)) }
 
-// Less compares two hashes.
-func (h Hash) Less(other Hash) bool {
-	return bytes.Compare(h[:], other[:]) < 0
+// Cmp compares two hashes.
+func (h Hash) Cmp(other Hash) int {
+	return bytes.Compare(h[:], other[:])
 }
 
 // Bytes gets the byte representation of the underlying hash.
@@ -231,9 +231,9 @@ func IsHexAddress(s string) bool {
 	return len(s) == 2*AddressLength && isHex(s)
 }
 
-// Less compares two addresses.
-func (a Address) Less(other Address) bool {
-	return bytes.Compare(a[:], other[:]) < 0
+// Cmp compares two addresses.
+func (a Address) Cmp(other Address) int {
+	return bytes.Compare(a[:], other[:])
 }
 
 // Bytes gets the string representation of the underlying address.
diff --git a/consensus/clique/snapshot.go b/consensus/clique/snapshot.go
index 0f1b9f4b3a..a97115121b 100644
--- a/consensus/clique/snapshot.go
+++ b/consensus/clique/snapshot.go
@@ -308,7 +308,7 @@ func (s *Snapshot) signers() []common.Address {
 	for sig := range s.Signers {
 		sigs = append(sigs, sig)
 	}
-	slices.SortFunc(sigs, common.Address.Less)
+	slices.SortFunc(sigs, common.Address.Cmp)
 	return sigs
 }
 
diff --git a/consensus/clique/snapshot_test.go b/consensus/clique/snapshot_test.go
index f30900f274..26cebe008a 100644
--- a/consensus/clique/snapshot_test.go
+++ b/consensus/clique/snapshot_test.go
@@ -53,7 +53,7 @@ func (ap *testerAccountPool) checkpoint(header *types.Header, signers []string)
 	for i, signer := range signers {
 		auths[i] = ap.address(signer)
 	}
-	slices.SortFunc(auths, common.Address.Less)
+	slices.SortFunc(auths, common.Address.Cmp)
 	for i, auth := range auths {
 		copy(header.Extra[extraVanity+i*common.AddressLength:], auth.Bytes())
 	}
diff --git a/core/blockchain.go b/core/blockchain.go
index 65bcbbacc9..036a740326 100644
--- a/core/blockchain.go
+++ b/core/blockchain.go
@@ -1053,8 +1053,8 @@ func (bc *BlockChain) procFutureBlocks() {
 		}
 	}
 	if len(blocks) > 0 {
-		slices.SortFunc(blocks, func(a, b *types.Block) bool {
-			return a.NumberU64() < b.NumberU64()
+		slices.SortFunc(blocks, func(a, b *types.Block) int {
+			return a.Number().Cmp(b.Number())
 		})
 		// Insert one by one as chain insertion needs contiguous ancestry between blocks
 		for i := range blocks {
diff --git a/core/rawdb/accessors_chain.go b/core/rawdb/accessors_chain.go
index 23cdc217b6..2bc245afb7 100644
--- a/core/rawdb/accessors_chain.go
+++ b/core/rawdb/accessors_chain.go
@@ -902,9 +902,9 @@ func WriteBadBlock(db ethdb.KeyValueStore, block *types.Block) {
 		Header: block.Header(),
 		Body:   block.Body(),
 	})
-	slices.SortFunc(badBlocks, func(a, b *badBlock) bool {
+	slices.SortFunc(badBlocks, func(a, b *badBlock) int {
 		// Note: sorting in descending number order.
-		return a.Header.Number.Uint64() >= b.Header.Number.Uint64()
+		return -a.Header.Number.Cmp(b.Header.Number)
 	})
 	if len(badBlocks) > badBlockToKeep {
 		badBlocks = badBlocks[:badBlockToKeep]
diff --git a/core/rawdb/chain_iterator_test.go b/core/rawdb/chain_iterator_test.go
index 9e18c8605c..9580cd92a8 100644
--- a/core/rawdb/chain_iterator_test.go
+++ b/core/rawdb/chain_iterator_test.go
@@ -19,12 +19,12 @@ package rawdb
 import (
 	"math/big"
 	"reflect"
+	"sort"
 	"sync"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
-	"golang.org/x/exp/slices"
 )
 
 func TestChainIterator(t *testing.T) {
@@ -92,11 +92,9 @@ func TestChainIterator(t *testing.T) {
 			}
 		}
 		if !c.reverse {
-			slices.Sort(numbers)
+			sort.Ints(numbers)
 		} else {
-			slices.SortFunc(numbers, func(a, b int) bool {
-				return a > b // Sort descending
-			})
+			sort.Sort(sort.Reverse(sort.IntSlice(numbers)))
 		}
 		if !reflect.DeepEqual(numbers, c.expect) {
 			t.Fatalf("Case %d failed, visit element mismatch, want %v, got %v", i, c.expect, numbers)
diff --git a/core/state/snapshot/difflayer.go b/core/state/snapshot/difflayer.go
index b10b43b1ae..b6aca599c5 100644
--- a/core/state/snapshot/difflayer.go
+++ b/core/state/snapshot/difflayer.go
@@ -525,7 +525,7 @@ func (dl *diffLayer) AccountList() []common.Hash {
 			dl.accountList = append(dl.accountList, hash)
 		}
 	}
-	slices.SortFunc(dl.accountList, common.Hash.Less)
+	slices.SortFunc(dl.accountList, common.Hash.Cmp)
 	dl.memory += uint64(len(dl.accountList) * common.HashLength)
 	return dl.accountList
 }
@@ -563,7 +563,7 @@ func (dl *diffLayer) StorageList(accountHash common.Hash) ([]common.Hash, bool)
 	for k := range storageMap {
 		storageList = append(storageList, k)
 	}
-	slices.SortFunc(storageList, common.Hash.Less)
+	slices.SortFunc(storageList, common.Hash.Cmp)
 	dl.storageList[accountHash] = storageList
 	dl.memory += uint64(len(dl.storageList)*common.HashLength + common.HashLength)
 	return storageList, destructed
diff --git a/core/state/snapshot/iterator_fast.go b/core/state/snapshot/iterator_fast.go
index 339f930ffd..0502d9cf85 100644
--- a/core/state/snapshot/iterator_fast.go
+++ b/core/state/snapshot/iterator_fast.go
@@ -33,19 +33,25 @@ type weightedIterator struct {
 	priority int
 }
 
-func (it *weightedIterator) Less(other *weightedIterator) bool {
+func (it *weightedIterator) Cmp(other *weightedIterator) int {
 	// Order the iterators primarily by the account hashes
 	hashI := it.it.Hash()
 	hashJ := other.it.Hash()
 
 	switch bytes.Compare(hashI[:], hashJ[:]) {
 	case -1:
-		return true
+		return -1
 	case 1:
-		return false
+		return 1
 	}
 	// Same account/storage-slot in multiple layers, split by priority
-	return it.priority < other.priority
+	if it.priority < other.priority {
+		return -1
+	}
+	if it.priority > other.priority {
+		return 1
+	}
+	return 0
 }
 
 // fastIterator is a more optimized multi-layer iterator which maintains a
@@ -155,9 +161,7 @@ func (fi *fastIterator) init() {
 		}
 	}
 	// Re-sort the entire list
-	slices.SortFunc(fi.iterators, func(a, b *weightedIterator) bool {
-		return a.Less(b)
-	})
+	slices.SortFunc(fi.iterators, func(a, b *weightedIterator) int { return a.Cmp(b) })
 	fi.initiated = false
 }
 
diff --git a/eth/api_debug_test.go b/eth/api_debug_test.go
index 4b08bd4fc5..6a1b537c25 100644
--- a/eth/api_debug_test.go
+++ b/eth/api_debug_test.go
@@ -105,7 +105,7 @@ func TestAccountRange(t *testing.T) {
 	}
 	// Test to see if it's possible to recover from the middle of the previous
 	// set and get an even split between the first and second sets.
-	slices.SortFunc(hList, common.Hash.Less)
+	slices.SortFunc(hList, common.Hash.Cmp)
 	middleH := hList[AccountRangeMaxResults/2]
 	middleResult := accountRangeTest(t, &trie, sdb, middleH, AccountRangeMaxResults, AccountRangeMaxResults)
 	missing, infirst, insecond := 0, 0, 0
diff --git a/eth/gasprice/feehistory.go b/eth/gasprice/feehistory.go
index b9cee45ae7..226991b24b 100644
--- a/eth/gasprice/feehistory.go
+++ b/eth/gasprice/feehistory.go
@@ -111,8 +111,8 @@ func (oracle *Oracle) processBlock(bf *blockFees, percentiles []float64) {
 		reward, _ := tx.EffectiveGasTip(bf.block.BaseFee())
 		sorter[i] = txGasAndReward{gasUsed: bf.receipts[i].GasUsed, reward: reward}
 	}
-	slices.SortStableFunc(sorter, func(a, b txGasAndReward) bool {
-		return a.reward.Cmp(b.reward) < 0
+	slices.SortStableFunc(sorter, func(a, b txGasAndReward) int {
+		return a.reward.Cmp(b.reward)
 	})
 
 	var txIndex int
diff --git a/eth/gasprice/gasprice.go b/eth/gasprice/gasprice.go
index 9eccd72428..b719649811 100644
--- a/eth/gasprice/gasprice.go
+++ b/eth/gasprice/gasprice.go
@@ -208,7 +208,7 @@ func (oracle *Oracle) SuggestTipCap(ctx context.Context) (*big.Int, error) {
 	}
 	price := lastPrice
 	if len(results) > 0 {
-		slices.SortFunc(results, func(a, b *big.Int) bool { return a.Cmp(b) < 0 })
+		slices.SortFunc(results, func(a, b *big.Int) int { return a.Cmp(b) })
 		price = results[(len(results)-1)*oracle.percentile/100]
 	}
 	if price.Cmp(oracle.maxPrice) > 0 {
@@ -247,12 +247,12 @@ func (oracle *Oracle) getBlockValues(ctx context.Context, blockNum uint64, limit
 	sortedTxs := make([]*types.Transaction, len(txs))
 	copy(sortedTxs, txs)
 	baseFee := block.BaseFee()
-	slices.SortFunc(sortedTxs, func(a, b *types.Transaction) bool {
+	slices.SortFunc(sortedTxs, func(a, b *types.Transaction) int {
 		// It's okay to discard the error because a tx would never be
 		// accepted into a block with an invalid effective tip.
 		tip1, _ := a.EffectiveGasTip(baseFee)
 		tip2, _ := b.EffectiveGasTip(baseFee)
-		return tip1.Cmp(tip2) < 0
+		return tip1.Cmp(tip2)
 	})
 
 	var prices []*big.Int
diff --git a/eth/protocols/snap/sync_test.go b/eth/protocols/snap/sync_test.go
index 8b09cd8c84..1514ad4e13 100644
--- a/eth/protocols/snap/sync_test.go
+++ b/eth/protocols/snap/sync_test.go
@@ -1417,8 +1417,8 @@ type kv struct {
 	k, v []byte
 }
 
-func (k *kv) less(other *kv) bool {
-	return bytes.Compare(k.k, other.k) < 0
+func (k *kv) cmp(other *kv) int {
+	return bytes.Compare(k.k, other.k)
 }
 
 func key32(i uint64) []byte {
@@ -1478,7 +1478,7 @@ func makeAccountTrieNoStorage(n int, scheme string) (string, *trie.Trie, []*kv)
 		accTrie.MustUpdate(elem.k, elem.v)
 		entries = append(entries, elem)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	// Commit the state changes into db and re-create the trie
 	// for accessing later.
@@ -1540,7 +1540,7 @@ func makeBoundaryAccountTrie(scheme string, n int) (string, *trie.Trie, []*kv) {
 		accTrie.MustUpdate(elem.k, elem.v)
 		entries = append(entries, elem)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	// Commit the state changes into db and re-create the trie
 	// for accessing later.
@@ -1587,7 +1587,7 @@ func makeAccountTrieWithStorageWithUniqueStorage(scheme string, accounts, slots
 		storageRoots[common.BytesToHash(key)] = stRoot
 		storageEntries[common.BytesToHash(key)] = stEntries
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	// Commit account trie
 	root, set, _ := accTrie.Commit(true)
@@ -1652,7 +1652,7 @@ func makeAccountTrieWithStorage(scheme string, accounts, slots int, code, bounda
 		storageRoots[common.BytesToHash(key)] = stRoot
 		storageEntries[common.BytesToHash(key)] = stEntries
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	// Commit account trie
 	root, set, _ := accTrie.Commit(true)
@@ -1696,7 +1696,7 @@ func makeStorageTrieWithSeed(owner common.Hash, n, seed uint64, db *trie.Databas
 		trie.MustUpdate(elem.k, elem.v)
 		entries = append(entries, elem)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 	root, nodes, _ := trie.Commit(false)
 	return root, nodes, entries
 }
@@ -1747,7 +1747,7 @@ func makeBoundaryStorageTrie(owner common.Hash, n int, db *trie.Database) (commo
 		trie.MustUpdate(elem.k, elem.v)
 		entries = append(entries, elem)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 	root, nodes, _ := trie.Commit(false)
 	return root, nodes, entries
 }
diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go
index 11d7ff4b69..0f78af9a01 100644
--- a/eth/tracers/api_test.go
+++ b/eth/tracers/api_test.go
@@ -790,7 +790,7 @@ func newAccounts(n int) (accounts []Account) {
 		addr := crypto.PubkeyToAddress(key.PublicKey)
 		accounts = append(accounts, Account{key: key, addr: addr})
 	}
-	slices.SortFunc(accounts, func(a, b Account) bool { return a.addr.Less(b.addr) })
+	slices.SortFunc(accounts, func(a, b Account) int { return a.addr.Cmp(b.addr) })
 	return accounts
 }
 
diff --git a/ethdb/dbtest/testsuite.go b/ethdb/dbtest/testsuite.go
index ac10ddde93..0d3d5f5aa6 100644
--- a/ethdb/dbtest/testsuite.go
+++ b/ethdb/dbtest/testsuite.go
@@ -527,7 +527,7 @@ func makeDataset(size, ksize, vsize int, order bool) ([][]byte, [][]byte) {
 		vals = append(vals, randBytes(vsize))
 	}
 	if order {
-		slices.SortFunc(keys, func(a, b []byte) bool { return bytes.Compare(a, b) < 0 })
+		slices.SortFunc(keys, func(a, b []byte) int { return bytes.Compare(a, b) })
 	}
 	return keys, vals
 }
diff --git a/go.mod b/go.mod
index 7694f6eeaf..e4273ef5b0 100644
--- a/go.mod
+++ b/go.mod
@@ -63,7 +63,7 @@ require (
 	github.com/urfave/cli/v2 v2.24.1
 	go.uber.org/automaxprocs v1.5.2
 	golang.org/x/crypto v0.9.0
-	golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc
+	golang.org/x/exp v0.0.0-20230810033253-352e893a4cad
 	golang.org/x/sync v0.3.0
 	golang.org/x/sys v0.9.0
 	golang.org/x/text v0.9.0
@@ -125,7 +125,7 @@ require (
 	github.com/tklauser/go-sysconf v0.3.5 // indirect
 	github.com/tklauser/numcpus v0.2.2 // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
-	golang.org/x/mod v0.10.0 // indirect
+	golang.org/x/mod v0.11.0 // indirect
 	golang.org/x/net v0.10.0 // indirect
 	golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df // indirect
 	google.golang.org/protobuf v1.28.1 // indirect
diff --git a/go.sum b/go.sum
index a54b22e3dc..50271e857f 100644
--- a/go.sum
+++ b/go.sum
@@ -479,8 +479,8 @@ golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5y
 golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
 golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc h1:mCRnTeVUjcrhlRmO0VK8a6k6Rrf6TF9htwo2pJVSjIU=
-golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
+golang.org/x/exp v0.0.0-20230810033253-352e893a4cad h1:g0bG7Z4uG+OgH2QDODnjp6ggkk1bJDsINcuWmJN1iJU=
+golang.org/x/exp v0.0.0-20230810033253-352e893a4cad/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
@@ -490,8 +490,8 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.10.0 h1:lFO9qtOdlre5W1jxS3r/4szv2/6iXxScdzjoBMXNhYk=
-golang.org/x/mod v0.10.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.11.0 h1:bUO06HqtnRcc/7l71XBe4WcqTZ+3AH1J59zWDDwLKgU=
+golang.org/x/mod v0.11.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
diff --git a/internal/ethapi/api_test.go b/internal/ethapi/api_test.go
index 671b9b2e49..b0877dc378 100644
--- a/internal/ethapi/api_test.go
+++ b/internal/ethapi/api_test.go
@@ -817,7 +817,7 @@ func newAccounts(n int) (accounts []Account) {
 		addr := crypto.PubkeyToAddress(key.PublicKey)
 		accounts = append(accounts, Account{key: key, addr: addr})
 	}
-	slices.SortFunc(accounts, func(a, b Account) bool { return a.addr.Less(b.addr) })
+	slices.SortFunc(accounts, func(a, b Account) int { return a.addr.Cmp(b.addr) })
 	return accounts
 }
 
diff --git a/les/servingqueue.go b/les/servingqueue.go
index c25925403a..68cad9cb5a 100644
--- a/les/servingqueue.go
+++ b/les/servingqueue.go
@@ -215,8 +215,14 @@ func (sq *servingQueue) freezePeers() {
 		tasks.list = append(tasks.list, task)
 		tasks.sumTime += task.expTime
 	}
-	slices.SortFunc(peerList, func(a, b *peerTasks) bool {
-		return a.priority < b.priority
+	slices.SortFunc(peerList, func(a, b *peerTasks) int {
+		if a.priority < b.priority {
+			return -1
+		}
+		if a.priority > b.priority {
+			return 1
+		}
+		return 0
 	})
 	drop := true
 	for _, tasks := range peerList {
diff --git a/les/utils/limiter.go b/les/utils/limiter.go
index 155bd80150..70b7ff64f7 100644
--- a/les/utils/limiter.go
+++ b/les/utils/limiter.go
@@ -369,8 +369,14 @@ func (l *Limiter) dropRequests() {
 			priority: w / float64(nq.sumCost),
 		})
 	}
-	slices.SortFunc(list, func(a, b dropListItem) bool {
-		return a.priority < b.priority
+	slices.SortFunc(list, func(a, b dropListItem) int {
+		if a.priority < b.priority {
+			return -1
+		}
+		if a.priority < b.priority {
+			return 1
+		}
+		return 0
 	})
 	for _, item := range list {
 		for _, request := range item.nq.queue {
diff --git a/metrics/writer.go b/metrics/writer.go
index 3d60485b6b..82434e9d1d 100644
--- a/metrics/writer.go
+++ b/metrics/writer.go
@@ -3,6 +3,7 @@ package metrics
 import (
 	"fmt"
 	"io"
+	"strings"
 	"time"
 
 	"golang.org/x/exp/slices"
@@ -23,8 +24,7 @@ func WriteOnce(r Registry, w io.Writer) {
 	r.Each(func(name string, i interface{}) {
 		namedMetrics = append(namedMetrics, namedMetric{name, i})
 	})
-
-	slices.SortFunc(namedMetrics, namedMetric.less)
+	slices.SortFunc(namedMetrics, namedMetric.cmp)
 	for _, namedMetric := range namedMetrics {
 		switch metric := namedMetric.m.(type) {
 		case Counter:
@@ -92,6 +92,6 @@ type namedMetric struct {
 	m    interface{}
 }
 
-func (m namedMetric) less(other namedMetric) bool {
-	return m.name < other.name
+func (m namedMetric) cmp(other namedMetric) int {
+	return strings.Compare(m.name, other.name)
 }
diff --git a/metrics/writer_test.go b/metrics/writer_test.go
index a4c92addc9..8376bf8975 100644
--- a/metrics/writer_test.go
+++ b/metrics/writer_test.go
@@ -14,7 +14,7 @@ func TestMetricsSorting(t *testing.T) {
 		{name: "ggg"},
 	}
 
-	slices.SortFunc(namedMetrics, namedMetric.less)
+	slices.SortFunc(namedMetrics, namedMetric.cmp)
 	for i, name := range []string{"bbb", "fff", "ggg", "zzz"} {
 		if namedMetrics[i].name != name {
 			t.Fail()
diff --git a/p2p/discover/table_util_test.go b/p2p/discover/table_util_test.go
index 52544a2c93..8f3813bdcf 100644
--- a/p2p/discover/table_util_test.go
+++ b/p2p/discover/table_util_test.go
@@ -217,14 +217,14 @@ func nodeEqual(n1 *enode.Node, n2 *enode.Node) bool {
 }
 
 func sortByID(nodes []*enode.Node) {
-	slices.SortFunc(nodes, func(a, b *enode.Node) bool {
-		return string(a.ID().Bytes()) < string(b.ID().Bytes())
+	slices.SortFunc(nodes, func(a, b *enode.Node) int {
+		return bytes.Compare(a.ID().Bytes(), b.ID().Bytes())
 	})
 }
 
 func sortedByDistanceTo(distbase enode.ID, slice []*node) bool {
-	return slices.IsSortedFunc(slice, func(a, b *node) bool {
-		return enode.DistCmp(distbase, a.ID(), b.ID()) < 0
+	return slices.IsSortedFunc(slice, func(a, b *node) int {
+		return enode.DistCmp(distbase, a.ID(), b.ID())
 	})
 }
 
diff --git a/p2p/discover/v4_lookup_test.go b/p2p/discover/v4_lookup_test.go
index 83c4626288..1f9ad69d0a 100644
--- a/p2p/discover/v4_lookup_test.go
+++ b/p2p/discover/v4_lookup_test.go
@@ -302,8 +302,8 @@ func (tn *preminedTestnet) closest(n int) (nodes []*enode.Node) {
 			nodes = append(nodes, tn.node(d, i))
 		}
 	}
-	slices.SortFunc(nodes, func(a, b *enode.Node) bool {
-		return enode.DistCmp(tn.target.id(), a.ID(), b.ID()) < 0
+	slices.SortFunc(nodes, func(a, b *enode.Node) int {
+		return enode.DistCmp(tn.target.id(), a.ID(), b.ID())
 	})
 	return nodes[:n]
 }
diff --git a/p2p/discover/v5_udp_test.go b/p2p/discover/v5_udp_test.go
index 887d46c497..880b71a991 100644
--- a/p2p/discover/v5_udp_test.go
+++ b/p2p/discover/v5_udp_test.go
@@ -61,8 +61,8 @@ func TestUDPv5_lookupE2E(t *testing.T) {
 	for i := range nodes {
 		expectedResult[i] = nodes[i].Self()
 	}
-	slices.SortFunc(expectedResult, func(a, b *enode.Node) bool {
-		return enode.DistCmp(target.ID(), a.ID(), b.ID()) < 0
+	slices.SortFunc(expectedResult, func(a, b *enode.Node) int {
+		return enode.DistCmp(target.ID(), a.ID(), b.ID())
 	})
 
 	// Do the lookup.
diff --git a/p2p/dnsdisc/tree.go b/p2p/dnsdisc/tree.go
index f91aff458f..06b7681f18 100644
--- a/p2p/dnsdisc/tree.go
+++ b/p2p/dnsdisc/tree.go
@@ -214,8 +214,8 @@ func (t *Tree) build(entries []entry) entry {
 }
 
 func sortByID(nodes []*enode.Node) []*enode.Node {
-	slices.SortFunc(nodes, func(a, b *enode.Node) bool {
-		return bytes.Compare(a.ID().Bytes(), b.ID().Bytes()) < 0
+	slices.SortFunc(nodes, func(a, b *enode.Node) int {
+		return bytes.Compare(a.ID().Bytes(), b.ID().Bytes())
 	})
 	return nodes
 }
diff --git a/p2p/peer.go b/p2p/peer.go
index e800be80fc..65a7903f58 100644
--- a/p2p/peer.go
+++ b/p2p/peer.go
@@ -386,7 +386,7 @@ func countMatchingProtocols(protocols []Protocol, caps []Cap) int {
 
 // matchProtocols creates structures for matching named subprotocols.
 func matchProtocols(protocols []Protocol, caps []Cap, rw MsgReadWriter) map[string]*protoRW {
-	slices.SortFunc(caps, Cap.Less)
+	slices.SortFunc(caps, Cap.Cmp)
 	offset := baseProtocolLength
 	result := make(map[string]*protoRW)
 
diff --git a/p2p/protocol.go b/p2p/protocol.go
index 4b3cca6d4a..9bb6785a22 100644
--- a/p2p/protocol.go
+++ b/p2p/protocol.go
@@ -18,6 +18,7 @@ package p2p
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
@@ -77,10 +78,16 @@ func (cap Cap) String() string {
 	return fmt.Sprintf("%s/%d", cap.Name, cap.Version)
 }
 
-// Less defines the canonical sorting order of capabilities.
-func (cap Cap) Less(other Cap) bool {
+// Cmp defines the canonical sorting order of capabilities.
+func (cap Cap) Cmp(other Cap) int {
 	if cap.Name == other.Name {
-		return cap.Version < other.Version
+		if cap.Version < other.Version {
+			return -1
+		}
+		if cap.Version > other.Version {
+			return 1
+		}
+		return 0
 	}
-	return cap.Name < other.Name
+	return strings.Compare(cap.Name, other.Name)
 }
diff --git a/p2p/server.go b/p2p/server.go
index d4e2be6783..8f42765a8c 100644
--- a/p2p/server.go
+++ b/p2p/server.go
@@ -510,7 +510,7 @@ func (srv *Server) setupLocalNode() error {
 	for _, p := range srv.Protocols {
 		srv.ourHandshake.Caps = append(srv.ourHandshake.Caps, p.cap())
 	}
-	slices.SortFunc(srv.ourHandshake.Caps, Cap.Less)
+	slices.SortFunc(srv.ourHandshake.Caps, Cap.Cmp)
 
 	// Create the local node.
 	db, err := enode.OpenDB(srv.NodeDatabase)
diff --git a/tests/fuzzers/rangeproof/rangeproof-fuzzer.go b/tests/fuzzers/rangeproof/rangeproof-fuzzer.go
index 34f3959ff8..ba490b761f 100644
--- a/tests/fuzzers/rangeproof/rangeproof-fuzzer.go
+++ b/tests/fuzzers/rangeproof/rangeproof-fuzzer.go
@@ -98,8 +98,8 @@ func (f *fuzzer) fuzz() int {
 	if len(entries) <= 1 {
 		return 0
 	}
-	slices.SortFunc(entries, func(a, b *kv) bool {
-		return bytes.Compare(a.k, b.k) < 0
+	slices.SortFunc(entries, func(a, b *kv) int {
+		return bytes.Compare(a.k, b.k)
 	})
 
 	var ok = 0
diff --git a/tests/fuzzers/stacktrie/trie_fuzzer.go b/tests/fuzzers/stacktrie/trie_fuzzer.go
index b8e13f96d1..3d65524095 100644
--- a/tests/fuzzers/stacktrie/trie_fuzzer.go
+++ b/tests/fuzzers/stacktrie/trie_fuzzer.go
@@ -182,8 +182,8 @@ func (f *fuzzer) fuzz() int {
 	dbA.Commit(rootA, false)
 
 	// Stacktrie requires sorted insertion
-	slices.SortFunc(vals, func(a, b kv) bool {
-		return bytes.Compare(a.k, b.k) < 0
+	slices.SortFunc(vals, func(a, b kv) int {
+		return bytes.Compare(a.k, b.k)
 	})
 	for _, kv := range vals {
 		if f.debugging {
diff --git a/trie/iterator_test.go b/trie/iterator_test.go
index 5dc1faed59..57d1f06a16 100644
--- a/trie/iterator_test.go
+++ b/trie/iterator_test.go
@@ -81,8 +81,8 @@ type kv struct {
 	t    bool
 }
 
-func (k *kv) less(other *kv) bool {
-	return bytes.Compare(k.k, other.k) < 0
+func (k *kv) cmp(other *kv) int {
+	return bytes.Compare(k.k, other.k)
 }
 
 func TestIteratorLargeData(t *testing.T) {
diff --git a/trie/proof_test.go b/trie/proof_test.go
index c943194586..fc2de62649 100644
--- a/trie/proof_test.go
+++ b/trie/proof_test.go
@@ -173,7 +173,7 @@ func TestRangeProof(t *testing.T) {
 	for _, kv := range vals {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 	for i := 0; i < 500; i++ {
 		start := mrand.Intn(len(entries))
 		end := mrand.Intn(len(entries)-start) + start + 1
@@ -206,7 +206,7 @@ func TestRangeProofWithNonExistentProof(t *testing.T) {
 	for _, kv := range vals {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 	for i := 0; i < 500; i++ {
 		start := mrand.Intn(len(entries))
 		end := mrand.Intn(len(entries)-start) + start + 1
@@ -278,7 +278,7 @@ func TestRangeProofWithInvalidNonExistentProof(t *testing.T) {
 	for _, kv := range vals {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	// Case 1
 	start, end := 100, 200
@@ -335,7 +335,7 @@ func TestOneElementRangeProof(t *testing.T) {
 	for _, kv := range vals {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	// One element with existent edge proof, both edge proofs
 	// point to the SAME key.
@@ -422,7 +422,7 @@ func TestAllElementsProof(t *testing.T) {
 	for _, kv := range vals {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	var k [][]byte
 	var v [][]byte
@@ -474,7 +474,7 @@ func TestSingleSideRangeProof(t *testing.T) {
 			trie.MustUpdate(value.k, value.v)
 			entries = append(entries, value)
 		}
-		slices.SortFunc(entries, (*kv).less)
+		slices.SortFunc(entries, (*kv).cmp)
 
 		var cases = []int{0, 1, 50, 100, 1000, 2000, len(entries) - 1}
 		for _, pos := range cases {
@@ -509,7 +509,7 @@ func TestReverseSingleSideRangeProof(t *testing.T) {
 			trie.MustUpdate(value.k, value.v)
 			entries = append(entries, value)
 		}
-		slices.SortFunc(entries, (*kv).less)
+		slices.SortFunc(entries, (*kv).cmp)
 
 		var cases = []int{0, 1, 50, 100, 1000, 2000, len(entries) - 1}
 		for _, pos := range cases {
@@ -543,7 +543,7 @@ func TestBadRangeProof(t *testing.T) {
 	for _, kv := range vals {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	for i := 0; i < 500; i++ {
 		start := mrand.Intn(len(entries))
@@ -646,7 +646,7 @@ func TestSameSideProofs(t *testing.T) {
 	for _, kv := range vals {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	pos := 1000
 	first := decreaseKey(common.CopyBytes(entries[pos].k))
@@ -690,7 +690,7 @@ func TestHasRightElement(t *testing.T) {
 		trie.MustUpdate(value.k, value.v)
 		entries = append(entries, value)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	var cases = []struct {
 		start   int
@@ -762,7 +762,7 @@ func TestEmptyRangeProof(t *testing.T) {
 	for _, kv := range vals {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	var cases = []struct {
 		pos int
@@ -797,7 +797,7 @@ func TestBloatedProof(t *testing.T) {
 	for _, kv := range kvs {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 	var keys [][]byte
 	var vals [][]byte
 
@@ -831,7 +831,7 @@ func TestEmptyValueRangeProof(t *testing.T) {
 	for _, kv := range values {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	// Create a new entry with a slightly modified key
 	mid := len(entries) / 2
@@ -875,7 +875,7 @@ func TestAllElementsEmptyValueRangeProof(t *testing.T) {
 	for _, kv := range values {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	// Create a new entry with a slightly modified key
 	mid := len(entries) / 2
@@ -981,7 +981,7 @@ func benchmarkVerifyRangeProof(b *testing.B, size int) {
 	for _, kv := range vals {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	start := 2
 	end := start + size
@@ -1018,7 +1018,7 @@ func benchmarkVerifyRangeNoProof(b *testing.B, size int) {
 	for _, kv := range vals {
 		entries = append(entries, kv)
 	}
-	slices.SortFunc(entries, (*kv).less)
+	slices.SortFunc(entries, (*kv).cmp)
 
 	var keys [][]byte
 	var values [][]byte
diff --git a/trie/triedb/pathdb/history.go b/trie/triedb/pathdb/history.go
index c12fc55184..ce82532507 100644
--- a/trie/triedb/pathdb/history.go
+++ b/trie/triedb/pathdb/history.go
@@ -262,20 +262,20 @@ func newHistory(root common.Hash, parent common.Hash, block uint64, states *trie
 	for addr := range states.Accounts {
 		accountList = append(accountList, addr)
 	}
-	slices.SortFunc(accountList, func(a, b common.Address) bool { return a.Less(b) })
+	slices.SortFunc(accountList, common.Address.Cmp)
 
 	for addr, slots := range states.Storages {
 		slist := make([]common.Hash, 0, len(slots))
 		for slotHash := range slots {
 			slist = append(slist, slotHash)
 		}
-		slices.SortFunc(slist, func(a, b common.Hash) bool { return a.Less(b) })
+		slices.SortFunc(slist, common.Hash.Cmp)
 		storageList[addr] = slist
 	}
 	for addr := range states.Incomplete {
 		incomplete = append(incomplete, addr)
 	}
-	slices.SortFunc(incomplete, func(a, b common.Address) bool { return a.Less(b) })
+	slices.SortFunc(incomplete, common.Address.Cmp)
 
 	return &history{
 		meta: &meta{
diff --git a/trie/triedb/pathdb/testutils.go b/trie/triedb/pathdb/testutils.go
index 2efac87198..d6fdacb421 100644
--- a/trie/triedb/pathdb/testutils.go
+++ b/trie/triedb/pathdb/testutils.go
@@ -117,7 +117,7 @@ func hash(states map[common.Hash][]byte) (common.Hash, []byte) {
 	for hash := range states {
 		hs = append(hs, hash)
 	}
-	slices.SortFunc(hs, func(a, b common.Hash) bool { return a.Less(b) })
+	slices.SortFunc(hs, common.Hash.Cmp)
 
 	var input []byte
 	for _, hash := range hs {
diff --git a/trie/trienode/node.go b/trie/trienode/node.go
index 8998bcba06..98d5588b6d 100644
--- a/trie/trienode/node.go
+++ b/trie/trienode/node.go
@@ -18,10 +18,10 @@ package trienode
 
 import (
 	"fmt"
+	"sort"
 	"strings"
 
 	"github.com/ethereum/go-ethereum/common"
-	"golang.org/x/exp/slices"
 )
 
 // Node is a wrapper which contains the encoded blob of the trie node and its
@@ -83,9 +83,7 @@ func (set *NodeSet) ForEachWithOrder(callback func(path string, n *Node)) {
 		paths = append(paths, path)
 	}
 	// Bottom-up, the longest path first
-	slices.SortFunc(paths, func(a, b string) bool {
-		return a > b // Sort in reverse order
-	})
+	sort.Sort(sort.Reverse(sort.StringSlice(paths)))
 	for _, path := range paths {
 		callback(path, set.Nodes[path])
 	}