fix(gnogenesis): sort balances before export for deterministic checksum of genesis.json

This change sorts balances by lexicographic order to ensure that
the checksum produced by the genesis.json is deterministic.

Fixes #4122

Author: odeke-em

contribs/gnogenesis/internal/balances/balances_export.go

@@ -62,8 +62,10 @@ func execBalancesExport(cfg *balancesCfg, io commands.IO, args []string) error {
 	}
 	defer outputFile.Close()
 
+	balances := state.Balances.ToList()
+
 	// Save the balances
-	for _, balance := range state.Balances {
+	for _, balance := range balances {
 		if _, err = outputFile.WriteString(
 			fmt.Sprintf("%s\n", balance),
 		); err != nil {

contribs/gnogenesis/internal/balances/balances_export_test.go

@@ -105,7 +105,7 @@ func TestGenesis_Balances_Export(t *testing.T) {
 		t.Parallel()
 
 		// Generate dummy balances
-		balances := getDummyBalances(t, 10)
+		balances := getDummyBalances(t, 100)
 
 		tempGenesis, cleanup := testutils.NewTestFile(t)
 		t.Cleanup(cleanup)
@@ -146,11 +146,17 @@ func TestGenesis_Balances_Export(t *testing.T) {
 		}
 
 		require.NoError(t, scanner.Err())
-
 		assert.Len(t, outputBalances, len(balances))
 
-		for index, balance := range outputBalances {
-			assert.Equal(t, balances[index], balance)
+		// Lastly ensure that all balances are sorted by address, deterministically.
+		for i := 1; i < len(outputBalances); i++ {
+			for j := 0; j < i; i++ {
+				prev := outputBalances[j].Address
+				curr := outputBalances[i].Address
+				if balanceCompare(prev, curr) == 1 {
+					t.Fatalf("Non-deterministic order of exported balances\n\t[%d](%x)\n>\n\t[%d](%x)", i-1, prev, i, curr)
+				}
+			}
 		}
 	})
 }

gno.land/pkg/gnoland/balance.go

@@ -2,8 +2,10 @@ package gnoland
 
 import (
 	"bufio"
+	"bytes"
 	"fmt"
 	"io"
+	"sort"
 	"strings"
 
 	bft "github.com/gnolang/gno/tm2/pkg/bft/types"
@@ -79,14 +81,29 @@ func (bs Balances) Get(address crypto.Address) (balance Balance, ok bool) {
 	return
 }
 
+// List returns a slice of balances, sorted by Balance.Address
+// in lexicographic order.
 func (bs Balances) List() []Balance {
 	list := make([]Balance, 0, len(bs))
 	for _, balance := range bs {
 		list = append(list, balance)
 	}
+
+	// Ensure that the balances are returned in a deterministic order.
+	// We are comparing by Address instead of .Amount whose type is Coins
+	// that then requires a deeper comparison by .Denom and .Amount which
+	// is unnecessary yet by the nature of each amount, each address will
+	// contain all the coins.
+	sort.Slice(list, func(i, j int) bool {
+		return compareAddresses(list[i].Address, list[j].Address) == -1
+	})
 	return list
 }
 
+func compareAddresses(a, b bft.Address) int {
+	return bytes.Compare([]byte(a[:]), []byte(b[:]))
+}
+
 // LeftMerge left-merges the two maps
 func (bs Balances) LeftMerge(from Balances) {
 	for key, bVal := range from {

gno.land/pkg/gnoland/balance_test.go

@@ -1,8 +1,10 @@
 package gnoland
 
 import (
+	crand "crypto/rand"
 	"fmt"
 	"math"
+	"math/rand"
 	"strconv"
 	"strings"
 	"testing"
@@ -274,3 +276,24 @@ func generateKeyFromSeed(seed []byte, index uint32) crypto.PrivKey {
 
 	return secp256k1.PrivKeySecp256k1(derivedPriv)
 }
+
+func TestBalancesList(t *testing.T) {
+	// 1. Generate and insert balances.
+	balances := NewBalances()
+	n := 100
+	rng := rand.New(rand.NewSource(10))
+	for i := 0; i < n; i++ {
+		var addr bft.Address
+		crand.Read(addr[:])
+		amount := std.NewCoins(std.NewCoin(ugnot.Denom, 1+rng.Int63n(100)))
+		balances.Set(addr, amount)
+	}
+
+	list := balances.List()
+	for i := 1; i < len(list); i++ {
+		for j := 0; j < i; j++ {
+			isLess := compareAddresses(list[j].Address, list[i].Address) <= 0
+			assert.True(t, isLess, "Address:\n\t#%d[%x]\n>\n\t#%d[%x]", j, list[j], i, list[i])
+		}
+	}
+}