feat: add valset injection through r/sys/validators (#2229)

## Description

This PR introduces an `EndBlocker` system for applying validator set
changes protocol level, based on on-chain events (from the `/r/sys/vals`
realm).

I've utilized an already existing system:
- validator set changes still stay managed protocol-level in
`ConsensusState` -> refactoring this is not a small feat, and saying
this is an understatement
- event switch utilized by the node that dumps new block / new
transaction events

The way this flow essentially works is the following:
1. An on-chain event happens that indicates a change in the validator
set (added / removed)
2. These events (ABCI events) are parsed as soon as they end up in a
transaction result (are pushed to the event system of the SDK). The
top-level ABCI event type needs to be`EventTx` (indicating it's a new TX
result). The underlying tx GnoVM events (`GnoEvent`) need to be from the
`/r/sys/validators` Realm, and be a validator addition / removal (type
defined in the Realm)
4. Events are parsed down into `abci.ValidatorUpdates`, which are
returned as a result of `EndBlocker`
5. This `EndBlocker` result is later read by the `ConsensusState`, and
the validator set changes are applied for the upcoming block in a series
of existing callbacks. This also keeps proposer priority logic in check.

Blocked by #2130 
Closes #1823 

```mermaid
---
title: on-chain validator set injection flow
---
flowchart TD
    subgraph app.go
        nesvw(["Node event switch"]) -. pass all block events .-> collector(["event collector"])
        collector -. subscribes to .-> nesvw

        collector -. filter new events .-> collector

        EB["func EndBlocker(...)"] == 1: fetch relevant events ==> collector
        collector -. 2: return events, if any .-> EB
    end

    subgraph gno.land/r/sys/validators.gno
        GC["func GetChanges(from int64) []validators.Validator"]

        addVal["func addValidator(...)"]
        removeVal["func removeValidator(...)"]
        PE["func NewPropExecutor(changesFn) proposal.Executor"]

        PE -. calls internally .-> addVal
        PE -. calls internally .-> removeVal

        addVal -. std emits ValidatorAdded .-> nesvw
        removeVal -. std emits ValidatorRemoved .-> nesvw
    end

    subgraph gno.land/r/gov/dao.gno
        EP["func ExecuteProposal(...)"]
        

        EP == executes on-chain ==>PE
    end

    subgraph user_proposal.gno
        main("func main() {...}")
        PR["govdao.Propose(...)"]

        main -. contains .-> CB
        main -. contains .-> PR

        CB("changesFn func() []validators.Validator {...}")

        CB== creates ==>PE
        CB("changesFn func() []validators.Validator {...}")

        PE == passed into ==> PR
    end

    A[/fa:fa-user User\] == gnokey maketx run ==> main
    GDV[/fa:fa-people-group GOVDAO members\] == manually call ==> EP

    EB == 3: execute VM call to get changes since last block ==> GC
    GC -. 4: return changes .-> EB

    EB -. 5: return response with valset changes .-> EBR([abci.ResponseEndBlock]) -- applied in --> AB
    subgraph Cosmos SDK
        AB["func ApplyBlock(...) {...}"]
    end
```

Related: #1945

<details><summary>Contributors' checklist...</summary>

- [ ] Added new tests, or not needed, or not feasible
- [ ] Provided an example (e.g. screenshot) to aid review or the PR is
self-explanatory
- [ ] Updated the official documentation or not needed
- [ ] No breaking changes were made, or a `BREAKING CHANGE: xxx` message
was included in the description
- [ ] Added references to related issues and PRs
- [ ] Provided any useful hints for running manual tests
- [ ] Added new benchmarks to [generated
graphs](https://gnoland.github.io/benchmarks), if any. More info
[here](https://github.com/gnolang/gno/blob/master/.benchmarks/README.md).
</details>

---------

Co-authored-by: Manfred Touron <94029+moul@users.noreply.github.com>

contribs/gnodev/pkg/dev/node.go

@@ -527,7 +527,7 @@ func buildNode(logger *slog.Logger, emitter emitter.Emitter, cfg *gnoland.InMemo
 func newNodeConfig(tmc *tmcfg.Config, chainid string, appstate gnoland.GnoGenesisState) *gnoland.InMemoryNodeConfig {
  // Create Mocked Identity
  pv := gnoland.NewMockedPrivValidator()
- genesis := gnoland.NewDefaultGenesisConfig(pv.GetPubKey(), chainid)
+ genesis := gnoland.NewDefaultGenesisConfig(chainid)
  genesis.AppState = appstate
 
  // Add self as validator

examples/gno.land/r/gov/dao/prop1_filetest.gno

@@ -91,7 +91,7 @@ func main() {
 // Status: succeeded
 // Author: g1wymu47drhr0kuq2098m792lytgtj2nyx77yrsm
 // --
-// Valset changes to apply:
-// - g12345678 (10)
-// - g000000000 (10)
-// - g000000000 (0)
+// Valset changes:
+// - #123: g12345678 (10)
+// - #123: g000000000 (10)
+// - #123: g000000000 (0)

examples/gno.land/r/sys/validators/gno.mod

@@ -1,6 +1,11 @@
 module gno.land/r/sys/validators
 
 require (
+ gno.land/p/demo/avl v0.0.0-latest
+ gno.land/p/demo/seqid v0.0.0-latest
+ gno.land/p/demo/testutils v0.0.0-latest
+ gno.land/p/demo/uassert v0.0.0-latest
+ gno.land/p/demo/ufmt v0.0.0-latest
  gno.land/p/gov/proposal v0.0.0-latest
  gno.land/p/nt/poa v0.0.0-latest
  gno.land/p/sys/validators v0.0.0-latest

examples/gno.land/r/sys/validators/gnosdk.gno

@@ -1,16 +1,24 @@
 package validators
 
-import "gno.land/p/sys/validators"
+import (
+ "gno.land/p/sys/validators"
+)
 
-// getChanges returns the validator changes stored on the realm.
-// This function is unexported and intended to be called by gno.land through the GnoSDK
-func getChanges() []validators.Validator {
- // Construct the changes
- valsetChanges := make([]validators.Validator, len(changes))
- copy(valsetChanges, changes)
+// GetChanges returns the validator changes stored on the realm, since the given block number.
+// This function is intended to be called by gno.land through the GnoSDK
+func GetChanges(from int64) []validators.Validator {
+ valsetChanges := make([]validators.Validator, 0)
 
- // Reset the changes set
- changes = changes[:0]
+ // Gather the changes from the specified block
+ changes.Iterate(getBlockID(from), "", func(_ string, value interface{}) bool {
+ chs := value.([]change)
+
+ for _, ch := range chs {
+ valsetChanges = append(valsetChanges, ch.validator)
+ }
+
+ return false
+ })
 
  return valsetChanges
 }

examples/gno.land/r/sys/validators/init.gno

@@ -1,14 +1,14 @@
 package validators
 
 import (
+ "gno.land/p/demo/avl"
  "gno.land/p/nt/poa"
- "gno.land/p/sys/validators"
 )
 
 func init() {
  // The default valset protocol is PoA
  vp = poa.NewPoA()
 
  // No changes to apply initially
- changes = make([]validators.Validator, 0)
+ changes = avl.NewTree()
 }

examples/gno.land/r/sys/validators/validators.gno

@@ -2,16 +2,24 @@ package validators
 
 import (
  "std"
- "strconv"
 
+ "gno.land/p/demo/avl"
+ "gno.land/p/demo/seqid"
+ "gno.land/p/demo/ufmt"
  "gno.land/p/sys/validators"
 )
 
 var (
  vp validators.ValsetProtocol // p is the underlying validator set protocol
- changes []validators.Validator // changes are the set changes that happened between scrapes
+ changes *avl.Tree  // changes holds any valset changes; seqid(block number) -> []change
 )
 
+// change represents a single valset change, tied to a specific block number
+type change struct {
+ blockNum int64 // the block number associated with the valset change
+ validator validators.Validator // the validator update
+}
+
 // addValidator adds a new validator to the validator set.
 // If the validator is already present, the method errors out
 func addValidator(validator validators.Validator) {
@@ -21,7 +29,12 @@ func addValidator(validator validators.Validator) {
  }
 
  // Validator added, note the change
- changes = append(changes, val)
+ ch := change{
+ blockNum: std.GetHeight(),
+ validator: val,
+ }
+
+ saveChange(ch)
 
  // Emit the validator set change
  std.Emit(validators.ValidatorAddedEvent)
@@ -36,25 +49,69 @@ func removeValidator(address std.Address) {
  }
 
  // Validator removed, note the change
- changes = append(changes, validators.Validator{
- Address: val.Address,
- PubKey: val.PubKey,
- VotingPower: 0, // nullified the voting power indicates removal
- })
+ ch := change{
+ blockNum: std.GetHeight(),
+ validator: validators.Validator{
+ Address: val.Address,
+ PubKey: val.PubKey,
+ VotingPower: 0, // nullified the voting power indicates removal
+ },
+ }
+
+ saveChange(ch)
 
  // Emit the validator set change
  std.Emit(validators.ValidatorRemovedEvent)
 }
 
+// saveChange saves the valset change
+func saveChange(ch change) {
+ id := getBlockID(ch.blockNum)
+
+ setRaw, exists := changes.Get(id)
+ if !exists {
+ changes.Set(id, []change{ch})
+
+ return
+ }
+
+ // Save the change
+ set := setRaw.([]change)
+ set = append(set, ch)
+
+ changes.Set(id, set)
+}
+
+// getBlockID converts the block number to a sequential ID
+func getBlockID(blockNum int64) string {
+ return seqid.ID(uint64(blockNum)).String()
+}
+
 func Render(_ string) string {
- if len(changes) == 0 {
+ var (
+ size = changes.Size()
+ maxDisplay = 10
+ )
+
+ if size == 0 {
  return "No valset changes to apply."
  }
 
- output := "Valset changes to apply:\n"
- for _, change := range changes {
- output += "- " + string(change.Address) + " (" + strconv.FormatUint(change.VotingPower, 10) + ")\n"
- }
+ output := "Valset changes:\n"
+ changes.ReverseIterateByOffset(size-maxDisplay, maxDisplay, func(_ string, value interface{}) bool {
+ chs := value.([]change)
+
+ for _, ch := range chs {
+ output += ufmt.Sprintf(
+ "- #%d: %s (%d)\n",
+ ch.blockNum,
+ ch.validator.Address.String(),
+ ch.validator.VotingPower,
+ )
+ }
+
+ return false
+ })
 
  return output
 }

examples/gno.land/r/sys/validators/validators_test.gno

@@ -0,0 +1,102 @@
+package validators
+
+import (
+ "testing"
+
+ "std"
+
+ "gno.land/p/demo/avl"
+ "gno.land/p/demo/testutils"
+ "gno.land/p/demo/uassert"
+ "gno.land/p/demo/ufmt"
+ "gno.land/p/sys/validators"
+)
+
+// generateTestValidators generates a dummy validator set
+func generateTestValidators(count int) []validators.Validator {
+ vals := make([]validators.Validator, 0, count)
+
+ for i := 0; i < count; i++ {
+ val := validators.Validator{
+ Address: testutils.TestAddress(ufmt.Sprintf("%d", i)),
+ PubKey: "public-key",
+ VotingPower: 10,
+ }
+
+ vals = append(vals, val)
+ }
+
+ return vals
+}
+
+func TestValidators_AddRemove(t *testing.T) {
+ // Clear any changes
+ changes = avl.NewTree()
+
+ var (
+ vals = generateTestValidators(100)
+ initialHeight = int64(123)
+ )
+
+ // Add in the validators
+ for _, val := range vals {
+ addValidator(val)
+
+ // Make sure the validator is added
+ uassert.True(t, vp.IsValidator(val.Address))
+
+ std.TestSkipHeights(1)
+ }
+
+ for i := initialHeight; i < initialHeight+int64(len(vals)); i++ {
+ // Make sure the changes are saved
+ chs := GetChanges(i)
+
+ // We use the funky index calculation to make sure
+ // changes are properly handled for each block span
+ uassert.Equal(t, initialHeight+int64(len(vals))-i, int64(len(chs)))
+
+ for index, val := range vals[i-initialHeight:] {
+ // Make sure the changes are equal to the additions
+ ch := chs[index]
+
+ uassert.Equal(t, val.Address, ch.Address)
+ uassert.Equal(t, val.PubKey, ch.PubKey)
+ uassert.Equal(t, val.VotingPower, ch.VotingPower)
+ }
+ }
+
+ // Save the beginning height for the removal
+ initialRemoveHeight := std.GetHeight()
+
+ // Clear any changes
+ changes = avl.NewTree()
+
+ // Remove the validators
+ for _, val := range vals {
+ removeValidator(val.Address)
+
+ // Make sure the validator is removed
+ uassert.False(t, vp.IsValidator(val.Address))
+
+ std.TestSkipHeights(1)
+ }
+
+ for i := initialRemoveHeight; i < initialRemoveHeight+int64(len(vals)); i++ {
+ // Make sure the changes are saved
+ chs := GetChanges(i)
+
+ // We use the funky index calculation to make sure
+ // changes are properly handled for each block span
+ uassert.Equal(t, initialRemoveHeight+int64(len(vals))-i, int64(len(chs)))
+
+ for index, val := range vals[i-initialRemoveHeight:] {
+ // Make sure the changes are equal to the additions
+ ch := chs[index]
+
+ uassert.Equal(t, val.Address, ch.Address)
+ uassert.Equal(t, val.PubKey, ch.PubKey)
+ uassert.Equal(t, uint64(0), ch.VotingPower)
+ }
+ }
+}

gno.land/cmd/gnoland/start.go

@@ -23,6 +23,7 @@ import (
  bft "github.com/gnolang/gno/tm2/pkg/bft/types"
  "github.com/gnolang/gno/tm2/pkg/commands"
  "github.com/gnolang/gno/tm2/pkg/crypto"
+ "github.com/gnolang/gno/tm2/pkg/events"
  osm "github.com/gnolang/gno/tm2/pkg/os"
  "github.com/gnolang/gno/tm2/pkg/telemetry"
  "go.uber.org/zap"
@@ -239,14 +240,17 @@ func execStart(ctx context.Context, c *startCfg, io commands.IO) error {
  io.Println(startGraphic)
  }
 
+ // Create a top-level shared event switch
+ evsw := events.NewEventSwitch()
+
  // Create application and node
- cfg.LocalApp, err = gnoland.NewApp(nodeDir, c.skipFailingGenesisTxs, logger, c.genesisMaxVMCycles)
+ cfg.LocalApp, err = gnoland.NewApp(nodeDir, c.skipFailingGenesisTxs, evsw, logger)
  if err != nil {
  return fmt.Errorf("unable to create the Gnoland app, %w", err)
  }
 
  // Create a default node, with the given setup
- gnoNode, err := node.DefaultNewNode(cfg, genesisPath, logger)
+ gnoNode, err := node.DefaultNewNode(cfg, genesisPath, evsw, logger)
  if err != nil {
  return fmt.Errorf("unable to create the Gnoland node, %w", err)
  }