feat: add genesis packages with transaction signing

contribs/gnodev/pkg/dev/node.go

@@ -489,6 +489,8 @@ func (n *Node) rebuildNode(ctx context.Context, genesis gnoland.GnoGenesisState)
 	// Speed up stdlib loading after first start (saves about 2-3 seconds on each reload).
 	nodeConfig.CacheStdlibLoad = true
 	nodeConfig.Genesis.ConsensusParams.Block.MaxGas = n.config.MaxGasPerBlock
+	// Genesis verification is always false with Gnodev
+	nodeConfig.SkipGenesisVerification = true
 
 	// recoverFromError handles panics and converts them to errors.
 	recoverFromError := func() {

contribs/gnogenesis/go.mod

@@ -30,6 +30,7 @@ require (
 	github.com/peterbourgon/ff/v3 v3.4.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rogpeppe/go-internal v1.12.0 // indirect
 	github.com/rs/cors v1.11.1 // indirect
 	github.com/rs/xid v1.6.0 // indirect
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
@@ -45,13 +46,16 @@ require (
 	go.opentelemetry.io/otel/trace v1.29.0 // indirect
 	go.opentelemetry.io/proto/otlp v1.3.1 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
+	go.uber.org/zap v1.27.0 // indirect
+	go.uber.org/zap/exp v0.3.0 // indirect
 	golang.org/x/crypto v0.26.0 // indirect
 	golang.org/x/exp v0.0.0-20240613232115-7f521ea00fb8 // indirect
 	golang.org/x/mod v0.20.0 // indirect
 	golang.org/x/net v0.28.0 // indirect
 	golang.org/x/sys v0.24.0 // indirect
 	golang.org/x/term v0.23.0 // indirect
 	golang.org/x/text v0.17.0 // indirect
+	golang.org/x/tools v0.24.0 // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20240822170219-fc7c04adadcd // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20240822170219-fc7c04adadcd // indirect
 	google.golang.org/grpc v1.65.0 // indirect

contribs/gnogenesis/internal/txs/txs_add_packages.go

@@ -5,38 +5,51 @@ import (
 	"errors"
 	"flag"
 	"fmt"
+	"os"
 
-	"github.com/gnolang/gno/tm2/pkg/crypto"
+	"github.com/gnolang/gno/tm2/pkg/crypto/keys"
 
+	"github.com/gnolang/gno/gno.land/pkg/gnoclient"
 	"github.com/gnolang/gno/gno.land/pkg/gnoland"
 	"github.com/gnolang/gno/gno.land/pkg/gnoland/ugnot"
+	"github.com/gnolang/gno/gno.land/pkg/integration"
 	"github.com/gnolang/gno/tm2/pkg/bft/types"
 	"github.com/gnolang/gno/tm2/pkg/commands"
 	"github.com/gnolang/gno/tm2/pkg/std"
 )
 
-var (
-	errInvalidPackageDir   = errors.New("invalid package directory")
-	errInvalidDeployerAddr = errors.New("invalid deployer address")
-)
+var errInvalidPackageDir = errors.New("invalid package directory")
 
 // Keep in sync with gno.land/cmd/start.go
-var (
-	defaultCreator   = crypto.MustAddressFromString("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") // test1
-	genesisDeployFee = std.NewFee(50000, std.MustParseCoin(ugnot.ValueString(1000000)))
-)
+var genesisDeployFee = std.NewFee(50000, std.MustParseCoin(ugnot.ValueString(1000000)))
 
 type addPkgCfg struct {
-	txsCfg          *txsCfg
-	deployerAddress string
+	txsCfg                *txsCfg
+	keyName               string
+	gnoHome               string // default GNOHOME env var, just here to ease testing with parallel tests
+	insecurePasswordStdin bool
 }
 
 func (c *addPkgCfg) RegisterFlags(fs *flag.FlagSet) {
 	fs.StringVar(
-		&c.deployerAddress,
-		"deployer-address",
-		defaultCreator.String(),
-		"the address that will be used to deploy the package",
+		&c.keyName,
+		"key-name",
+		"",
+		"The package deployer key name or address",
+	)
+
+	fs.StringVar(
+		&c.gnoHome,
+		"gno-home",
+		os.Getenv("GNOHOME"),
+		"the gno home directory",
+	)
+
+	fs.BoolVar(
+		&c.insecurePasswordStdin,
+		"insecure-password-stdin",
+		false,
+		"the gno home directory",
 	)
 }
 
@@ -76,27 +89,28 @@ func execTxsAddPackages(
 		return errInvalidPackageDir
 	}
 
-	var (
-		creator = defaultCreator
-		err     error
-	)
+	signer, err := signerWithConfig(cfg, io, genesis.ChainID)
+	if err != nil {
+		return fmt.Errorf("unable to load signer, %w", err)
+	}
 
-	// Check if the deployer address is set
-	if cfg.deployerAddress != defaultCreator.String() {
-		creator, err = crypto.AddressFromString(cfg.deployerAddress)
-		if err != nil {
-			return fmt.Errorf("%w, %w", errInvalidDeployerAddr, err)
-		}
+	info, err := signer.Info()
+	if err != nil {
+		return fmt.Errorf("unable to get signer info, %w", err)
 	}
 
 	parsedTxs := make([]gnoland.TxWithMetadata, 0)
 	for _, path := range args {
 		// Generate transactions from the packages (recursively)
-		txs, err := gnoland.LoadPackagesFromDir(path, creator, genesisDeployFee)
+		txs, err := gnoland.LoadPackagesFromDir(path, info.GetAddress(), genesisDeployFee)
 		if err != nil {
 			return fmt.Errorf("unable to load txs from directory, %w", err)
 		}
 
+		if err := signTxs(txs, signer); err != nil {
+			return fmt.Errorf("unable to sign txs, %w", err)
+		}
+
 		parsedTxs = append(parsedTxs, txs...)
 	}
 
@@ -117,3 +131,55 @@ func execTxsAddPackages(
 
 	return nil
 }
+
+func signTxs(txs []gnoland.TxWithMetadata, signer *gnoclient.SignerFromKeybase) error {
+	for index, tx := range txs {
+		signBytes, err := tx.Tx.GetSignBytes(signer.ChainID, 0, 0)
+		if err != nil {
+			return fmt.Errorf("unable to load txs from directory, %w", err)
+		}
+		signature, publicKey, err := signer.Keybase.Sign(signer.Account, signer.Password, signBytes)
+		txs[index].Tx.Signatures = []std.Signature{
+			{
+				PubKey:    publicKey,
+				Signature: signature,
+			},
+		}
+		if err != nil {
+			return fmt.Errorf("unable sign tx %w", err)
+		}
+	}
+
+	return nil
+}
+
+func signerWithConfig(cfg *addPkgCfg, io commands.IO, chainID string) (*gnoclient.SignerFromKeybase, error) {
+	var (
+		keyname = integration.DefaultAccount_Name
+		pass    string
+		kb      keys.Keybase
+		err     error
+	)
+
+	if cfg.keyName != "" {
+		keyname = cfg.keyName
+		kb, err = keys.NewKeyBaseFromDir(cfg.gnoHome)
+		if err != nil {
+			return nil, fmt.Errorf("unable to load keybase: %w", err)
+		}
+		pass, err = io.GetPassword("Enter password.", cfg.insecurePasswordStdin)
+		if err != nil {
+			return nil, fmt.Errorf("cannot read password: %w", err)
+		}
+	} else {
+		kb = keys.NewInMemory()
+		kb.CreateAccount(integration.DefaultAccount_Name, integration.DefaultAccount_Seed, "", "", 0, 0)
+	}
+
+	return &gnoclient.SignerFromKeybase{
+		Account:  keyname,
+		ChainID:  chainID,
+		Keybase:  kb,
+		Password: pass,
+	}, nil
+}