all: make use of some Go 1.22 std APIs

Sorting with the slices package and int-based compare funcs,
and making use of slices.Clone and cmp.Or to simplify code.

cmd/cli/editor.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"cmp"
 	"os"
 	"os/exec"
 	"strings"
@@ -16,13 +17,7 @@ type PreferredEditorResolver func() string
 // GetPreferredEditorFromEnvironment returns the user's editor as defined by the `$EDITOR` environment variable, or
 // the `DefaultEditor` if it is not set.
 func GetPreferredEditorFromEnvironment() string {
-	editor := os.Getenv("EDITOR")
-
-	if editor == "" {
-		return DefaultEditor
-	}
-
-	return editor
+	return cmp.Or(os.Getenv("EDITOR"), DefaultEditor)
 }
 
 func resolveEditorArguments(executable, filename string) []string {

db/metadb/metadb.go

@@ -1,6 +1,7 @@
 package metadb
 
 import (
+	"cmp"
 	"fmt"
 	"os"
 	"testing"
@@ -39,11 +40,7 @@ func New(typ, dir string) (db.Database, error) {
 }
 
 func ForTest() (typ string) {
-	dbType := os.Getenv("DVOTE_DB_TYPE")
-	if dbType == "" {
-		dbType = "pebble" // default to Pebble, just like vocdoninode
-	}
-	return dbType
+	return cmp.Or(os.Getenv("DVOTE_DB_TYPE"), "pebble") // default to Pebble, just like vocdoninode
 }
 
 func NewTest(tb testing.TB) db.Database {

log/log.go

@@ -2,6 +2,7 @@ package log
 
 import (
 	"bytes"
+	"cmp"
 	"fmt"
 	"io"
 	"os"
@@ -33,11 +34,7 @@ func init() {
 	// environment variable can be set globally even when running tests.
 	// Always initializing the logger is also useful to avoid panics when
 	// logging if the logger is nil.
-	level := "error"
-	if s := os.Getenv("LOG_LEVEL"); s != "" {
-		level = s
-	}
-	Init(level, "stderr", nil)
+	Init(cmp.Or(os.Getenv("LOG_LEVEL"), "error"), "stderr", nil)
 }
 
 // Logger provides access to the global logger (zerolog).

vochain/cometbft.go

@@ -2,12 +2,13 @@ package vochain
 
 import (
 	"bytes"
+	"cmp"
 	"context"
 	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"sort"
+	"slices"
 	"time"
 
 	cometabcitypes "github.com/cometbft/cometbft/abci/types"
@@ -349,7 +350,7 @@ func (app *BaseApplication) PrepareProposal(ctx context.Context,
 
 	type txInfo struct {
 		Data      []byte
-		Addr      *ethcommon.Address
+		Addr      ethcommon.Address
 		Nonce     uint32
 		DecodedTx *vochaintx.Tx
 	}
@@ -382,20 +383,11 @@ func (app *BaseApplication) PrepareProposal(ctx context.Context,
 	}
 
 	// Sort the transactions based on the sender's address and nonce
-	sort.Slice(validTxInfos, func(i, j int) bool {
-		if validTxInfos[i].Addr == nil && validTxInfos[j].Addr != nil {
-			return true
+	slices.SortFunc(validTxInfos, func(a, b txInfo) int {
+		if c := a.Addr.Cmp(b.Addr); c != 0 {
+			return c
 		}
-		if validTxInfos[i].Addr != nil && validTxInfos[j].Addr == nil {
-			return false
-		}
-		if validTxInfos[i].Addr != nil && validTxInfos[j].Addr != nil {
-			if bytes.Equal(validTxInfos[i].Addr.Bytes(), validTxInfos[j].Addr.Bytes()) {
-				return validTxInfos[i].Nonce < validTxInfos[j].Nonce
-			}
-			return bytes.Compare(validTxInfos[i].Addr.Bytes(), validTxInfos[j].Addr.Bytes()) == -1
-		}
-		return false
+		return cmp.Compare(a.Nonce, b.Nonce)
 	})
 
 	// Check the validity of the transactions

vochain/indexer/indexer.go

@@ -10,7 +10,7 @@ import (
 	"math/big"
 	"os"
 	"path/filepath"
-	"sort"
+	"slices"
 	"strings"
 	"sync"
 	"time"
@@ -384,7 +384,7 @@ func (idx *Indexer) Commit(height uint32) error {
 
 	// Update existing processes
 	updateProcs := maps.Keys(idx.blockUpdateProcs)
-	sort.Strings(updateProcs)
+	slices.Sort(updateProcs)
 
 	queries := idx.blockTxQueries()
 	ctx := context.TODO()

vochain/state/sik.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
+	"slices"
 
 	"github.com/ethereum/go-ethereum/common"
 	"go.vocdoni.io/dvote/db"
@@ -139,7 +140,7 @@ func (v *State) InvalidateSIK(address common.Address) error {
 func (v *State) ValidSIKRoots() [][]byte {
 	v.mtxValidSIKRoots.Lock()
 	defer v.mtxValidSIKRoots.Unlock()
-	return append([][]byte{}, v.validSIKRoots...)
+	return slices.Clone(v.validSIKRoots)
 }
 
 // FetchValidSIKRoots updates the list of current valid SIK roots in the current

vochain/state/votes.go

@@ -8,6 +8,7 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
+	"slices"
 
 	"go.vocdoni.io/dvote/crypto/ethereum"
 	"go.vocdoni.io/dvote/db"
@@ -82,11 +83,11 @@ func (v *Vote) Hash() []byte {
 // DeepCopy returns a deep copy of the Vote struct.
 func (v *Vote) DeepCopy() *Vote {
 	voteCopy := &Vote{
-		ProcessID:            append([]byte{}, v.ProcessID...),
-		Nullifier:            append([]byte{}, v.Nullifier...),
+		ProcessID:            slices.Clone(v.ProcessID),
+		Nullifier:            slices.Clone(v.Nullifier),
 		Height:               v.Height,
-		VotePackage:          append([]byte{}, v.VotePackage...),
-		EncryptionKeyIndexes: append([]uint32{}, v.EncryptionKeyIndexes...),
+		VotePackage:          slices.Clone(v.VotePackage),
+		EncryptionKeyIndexes: slices.Clone(v.EncryptionKeyIndexes),
 		Weight:               new(big.Int).Set(v.Weight),
 		VoterID:              v.VoterID,
 		Overwrites:           v.Overwrites,

vochain/transaction/nonce.go

@@ -14,7 +14,7 @@ import (
 // The function uses the signature of the transaction to derive the sender's public key and subsequently
 // the Ethereum address. The nonce is extracted based on the specific payload type of the transaction.
 // If the transaction does not contain signature or nonce, it returns the default values (nil and 0).
-func (t *TransactionHandler) ExtractNonceAndSender(vtx *vochaintx.Tx) (*common.Address, uint32, error) {
+func (t *TransactionHandler) ExtractNonceAndSender(vtx *vochaintx.Tx) (common.Address, uint32, error) {
 	var ptx interface {
 		GetNonce() uint32
 	}
@@ -29,7 +29,7 @@ func (t *TransactionHandler) ExtractNonceAndSender(vtx *vochaintx.Tx) (*common.A
 	case *models.Tx_SetAccount:
 		if payload.SetAccount.Txtype == models.TxType_CREATE_ACCOUNT {
 			// create account tx is a special case where the nonce is not relevant
-			return nil, 0, nil
+			return common.Address{}, 0, nil
 		}
 		ptx = payload.SetAccount
 	case *models.Tx_CollectFaucet:
@@ -38,25 +38,25 @@ func (t *TransactionHandler) ExtractNonceAndSender(vtx *vochaintx.Tx) (*common.A
 		*models.Tx_SetTransactionCosts, *models.Tx_DelSIK, *models.Tx_RegisterKey, *models.Tx_SetSIK,
 		*models.Tx_RegisterSIK:
 		// these tx does not have incremental nonce
-		return nil, 0, nil
+		return common.Address{}, 0, nil
 	default:
 		log.Errorf("unknown payload type on extract nonce: %T", payload)
 	}
 
 	if ptx == nil {
-		return nil, 0, fmt.Errorf("payload is nil")
+		return common.Address{}, 0, fmt.Errorf("payload is nil")
 	}
 
 	pubKey, err := ethereum.PubKeyFromSignature(vtx.SignedBody, vtx.Signature)
 	if err != nil {
-		return nil, 0, fmt.Errorf("cannot extract public key from vtx.Signature: %w", err)
+		return common.Address{}, 0, fmt.Errorf("cannot extract public key from vtx.Signature: %w", err)
 	}
 	addr, err := ethereum.AddrFromPublicKey(pubKey)
 	if err != nil {
-		return nil, 0, fmt.Errorf("cannot extract address from public key: %w", err)
+		return common.Address{}, 0, fmt.Errorf("cannot extract address from public key: %w", err)
 	}
 
-	return &addr, ptx.GetNonce(), nil
+	return addr, ptx.GetNonce(), nil
 }
 
 // checkAccountNonce checks if the nonce of the given transaction matches the nonce of the sender account.