feat: Multinode P2P sync and POA ( Proof of Authority )

gno.land/cmd/gnoland/README.md

@@ -6,8 +6,88 @@
     $> cd ./gno/gno.land
     $> make install.gnoland
 
-## Run `gnoland` full node
+## Option 1: Run `gnoland` full node for local development
 
     $> gnoland start
 
 Afterward, you can interact with [`gnokey`](../gnokey) or launch a [`gnoweb`](../gnoweb) interface.
+
+
+## Option 2: Run a node and sync with a Proof of Authority (POA) network
+
+ - gnoland init
+
+ - Download genesis.json from a trusted source and save it to the root-dir/config directory.
+
+ - Get the peer's node id from the node you trust.
+
+ - Start the node
+
+       $> gnoland start --persistent "node_id@peer_ip_address:port" or add the persistent_peers value in the ./testdir/config/config.toml
+
+## Option 3: Run a node as a Proof of Authority validator starting from genesis state
+
+- Initialize the config and key files.
+
+      $> gnoland init
+
+- Return the node info; we will need it to add to validator info in the genesis.json
+
+      $> gnoland node
+
+      Address: "g14t47gv3v2z3pc23g3zr39mnc99w2cplp0jhqvv"
+      Pubkey: "E5IFULgXFdS49ILgvPmO3/8chuSWfbqw3zYXaNEP+60="
+
+- Download genesis.json from a trusted source and save it to the root-dir/config directory.
+
+- Add your validator to the genesis file.
+
+      $> genesis validator add \
+       --address g14t47gv3v2z3pc23g3zr39mnc99w2cplp0jhqvv \
+       --pub-key E5IFULgXFdS49ILgvPmO3/8chuSWfbqw3zYXaNEP+60= \
+       --power 10 \
+       --name testvalidator2
+
+- Share the genesis with all trusted validators.
+
+- Get the peer's node id from the archive node you trust.
+
+- Start the node
+
+      $> gnoland start --persistent "node_id@peer_ip_address:port"
+
+  or add the persistent_peers value in the ./testdir/config/config.toml
+
+
+## Option 4: Run as an archive node starting from genesis state
+
+It's recommended to have at least two POA validator nodes running as archive nodes to bootstrap the network.
+
+Complete the steps in Option 4 and replace the last two steps with
+
+- Retrive node id and give it trusted peers.
+
+      $> gnoland node
+
+- Start the node
+
+      $> gnoland start --prune "nothing"
+
+
+## Reset `gnoland` node back to genesis state. It's suitable for running test node
+
+    $> gnoland unsafe-reset-all
+
+It removes the database and reset validator state back to genesis state but leaves the genesis.json and config.toml files unchanged.
+
+The `unsafe-reset-all` command is labeled "unsafe" because:
+
+1. It irreversibly deletes all node data, risking data loss.
+2. It may lead to double signing or chain forks in production.
+3. It resets the `priv_validator_state.json`, and can cause network disruption if uncoordinated.
+
+## Reset `gnoland` node history back to genesis state.
+
+ It removes the datastore and keeps the validator state unchanged. It reduces the risk of double signing and chain fork when we sync history state from the genesis. The validator will not sign a block until the node has synced, passing the state where the validator stopped signing.
+
+    $> gnoland reset-state

gno.land/cmd/gnoland/init.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"context"
+
+	"github.com/gnolang/gno/tm2/pkg/bft/privval"
+	"github.com/gnolang/gno/tm2/pkg/commands"
+	tmos "github.com/gnolang/gno/tm2/pkg/os"
+	"github.com/gnolang/gno/tm2/pkg/p2p"
+)
+
+// Display a node's persistent peer ID to the standard output.
+func newInitCmd(bc baseCfg) *commands.Command {
+	cmd := commands.NewCommand(
+		commands.Metadata{
+			Name:       "init",
+			ShortUsage: "init",
+			ShortHelp:  "initialize gnoland node",
+		},
+		nil,
+		func(_ context.Context, args []string) error {
+			return execInit(bc)
+		},
+	)
+	return cmd
+}
+
+func execInit(bc baseCfg) error {
+	config := bc.tmConfig
+	// private validator
+	privValKeyFile := config.PrivValidatorKeyFile()
+	privValStateFile := config.PrivValidatorStateFile()
+	var pv *privval.FilePV
+	if tmos.FileExists(privValKeyFile) {
+		logger.Info("Found private validator", "keyFile", privValKeyFile,
+			"stateFile", privValStateFile)
+	} else {
+		pv = privval.GenFilePV(privValKeyFile, privValStateFile)
+		pv.Save()
+		logger.Info("Generated private validator", "keyFile", privValKeyFile,
+			"stateFile", privValStateFile)
+	}
+
+	nodeKeyFile := config.NodeKeyFile()
+	if tmos.FileExists(nodeKeyFile) {
+		logger.Info("Found node key", "path", nodeKeyFile)
+	} else {
+		if _, err := p2p.LoadOrGenNodeKey(nodeKeyFile); err != nil {
+			return err
+		}
+		logger.Info("Generated node key", "path", nodeKeyFile)
+	}
+
+	return nil
+}

gno.land/cmd/gnoland/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+)
+
+func main() {
+	rootCmd := newRootCmd()
+	if err := rootCmd.ParseAndRun(context.Background(), os.Args[1:]); err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "%+v\n", err)
+		os.Exit(1)
+	}
+}

gno.land/cmd/gnoland/mockio.go

@@ -0,0 +1,116 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"os"
+)
+
+// This is for testing purposes only.
+// For mocking tests, we redirect os.Stdin so that we don't need to pass commands.IO,
+// which includes os.Stdin, to all the server commands. Exposing os.Stdin in a blockchain node is not safe.
+// This replaces the global variable and should not be used in concurrent tests. It's intended to simulate CLI input.
+// We purposely avoid using a mutex to prevent giving the wrong impression that it's suitable for parallel tests.
+
+type MockStdin struct {
+	origStdout   *os.File
+	stdoutReader *os.File
+
+	outCh chan []byte
+
+	origStdin   *os.File
+	stdinWriter *os.File
+}
+
+func NewMockStdin(input string) (*MockStdin, error) {
+	// Pipe for stdin. w ( stdinWriter ) -> r (stdin)
+	stdinReader, stdinWriter, err := os.Pipe()
+	if err != nil {
+		return nil, err
+	}
+
+	// Pipe for stdout. w( stdout ) -> r (stdoutReader)
+	stdoutReader, stdoutWriter, err := os.Pipe()
+	if err != nil {
+		return nil, err
+	}
+
+	origStdin := os.Stdin
+	os.Stdin = stdinReader
+
+	_, err = stdinWriter.Write([]byte(input))
+	if err != nil {
+		stdinWriter.Close()
+		os.Stdin = origStdin
+		return nil, err
+	}
+
+	origStdout := os.Stdout
+	os.Stdout = stdoutWriter
+
+	outCh := make(chan []byte)
+
+	// This goroutine reads stdout into a buffer in the background.
+	go func() {
+		var b bytes.Buffer
+		if _, err := io.Copy(&b, stdoutReader); err != nil {
+			log.Println(err)
+		}
+		outCh <- b.Bytes()
+	}()
+
+	return &MockStdin{
+		origStdout:   origStdout,
+		stdoutReader: stdoutReader,
+		outCh:        outCh,
+		origStdin:    origStdin,
+		stdinWriter:  stdinWriter,
+	}, nil
+}
+
+// ReadAndRestore collects all captured stdout and returns it; it also restores
+// os.Stdin and os.Stdout to their original values.
+func (i *MockStdin) ReadAndClose() ([]byte, error) {
+	if i.stdoutReader == nil {
+		return nil, fmt.Errorf("ReadAndRestore from closed MockStdin %v", i)
+	}
+
+	// Close the writer side of the faked stdout pipe. This signals to the
+	// background goroutine that it should exit.
+	os.Stdout.Close()
+	out := <-i.outCh
+
+	os.Stdout = i.origStdout
+	os.Stdin = i.origStdin
+
+	if i.stdoutReader != nil {
+		i.stdoutReader.Close()
+		i.stdoutReader = nil
+	}
+
+	if i.stdinWriter != nil {
+		i.stdinWriter.Close()
+		i.stdinWriter = nil
+	}
+
+	return out, nil
+}
+
+// Call this in a defer function to restore and close os.Stdout and os.Stdin.
+// This acts as a safeguard.
+func (i *MockStdin) Close() {
+	os.Stdout = i.origStdout
+	os.Stdin = i.origStdin
+
+	if i.stdoutReader != nil {
+		i.stdoutReader.Close()
+		i.stdoutReader = nil
+	}
+
+	if i.stdinWriter != nil {
+		i.stdinWriter.Close()
+		i.stdinWriter = nil
+	}
+}

gno.land/cmd/gnoland/node_id.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gnolang/gno/tm2/pkg/commands"
+	"github.com/gnolang/gno/tm2/pkg/p2p"
+)
+
+// Display a node's persistent peer ID to the standard output.
+func newNodeIDCmd(bc baseCfg) *commands.Command {
+	cmd := commands.NewCommand(
+		commands.Metadata{
+			Name:       "node",
+			ShortUsage: "node",
+			ShortHelp:  "display the node id for configuring persistent peers",
+		},
+		nil,
+		func(_ context.Context, args []string) error {
+			return execNodeID(bc)
+		},
+	)
+	return cmd
+}
+
+func execNodeID(bc baseCfg) error {
+	config := bc.tmConfig
+	nodeKey, err := p2p.LoadNodeKey(config.NodeKeyFile())
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("NodeID: %v\n", nodeKey.ID())
+	return nil
+}