feat(gnoland): chain hardfork mechanism v3

contribs/gnogenesis/genesis.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"github.com/gnolang/contribs/gnogenesis/internal/balances"
+	"github.com/gnolang/contribs/gnogenesis/internal/fork"
 	"github.com/gnolang/contribs/gnogenesis/internal/generate"
 	"github.com/gnolang/contribs/gnogenesis/internal/params"
 	"github.com/gnolang/contribs/gnogenesis/internal/txs"
@@ -28,6 +29,7 @@ func newGenesisCmd(io commands.IO) *commands.Command {
 		balances.NewBalancesCmd(io),
 		txs.NewTxsCmd(io),
 		params.NewParamsCmd(io),
+		fork.NewForkCmd(io),
 	)
 
 	return cmd

contribs/gnogenesis/internal/fork/addpkg.go

@@ -0,0 +1,144 @@
+package fork
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/gnolang/gno/gno.land/pkg/gnoland"
+	"github.com/gnolang/gno/gno.land/pkg/gnoland/ugnot"
+	"github.com/gnolang/gno/tm2/pkg/amino"
+	"github.com/gnolang/gno/tm2/pkg/commands"
+	"github.com/gnolang/gno/tm2/pkg/crypto"
+	"github.com/gnolang/gno/tm2/pkg/std"
+)
+
+// Default deployer for hardfork addpkg txs. The hardfork ceremony runs
+// with --skip-genesis-sig-verification=true, so the actual signature
+// is irrelevant; what matters is the deployer address that becomes
+// the package's owner. Mirrors gnogenesis txs add packages' default
+// account, which gnoland-1's genesis used.
+const defaultDeployerAddr = "g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5"
+
+// genesisDeployFee mirrors gno.land/cmd/start.go's genesis fee. Each
+// addpkg tx in the .jsonl carries the same fee for parity with the
+// fee used when these realms were originally deployed; under
+// --skip-genesis-sig-verification the fee is also un-checked.
+var genesisDeployFee = std.NewFee(50000, std.MustParseCoin(ugnot.ValueString(1)))
+
+type addpkgCfg struct {
+	output      string
+	deployerStr string
+}
+
+// newAddpkgCmd builds a deterministic .jsonl of MsgAddPackage txs
+// from one or more local package directories. Used during a hardfork
+// ceremony to deploy realms that don't exist on the source chain
+// (e.g., r/sys/validators/v3 when forking from gnoland-1, where v3
+// was added post-source-launch).
+//
+// Output format matches what `gnogenesis fork generate --migration-tx`
+// expects: gnoland.TxWithMetadata, one amino-JSON line per tx,
+// BlockHeight forced to 0 by readMigrationTxs at consume time.
+func newAddpkgCmd(io commands.IO) *commands.Command {
+	cfg := &addpkgCfg{}
+
+	return commands.NewCommand(
+		commands.Metadata{
+			Name:       "addpkg",
+			ShortUsage: "addpkg [flags] <pkgdir> [<pkgdir>...]",
+			ShortHelp:  "build a .jsonl of MsgAddPackage txs from local package dirs",
+			LongHelp: `Build a deterministic .jsonl of MsgAddPackage migration txs from one
+or more local package directories. Output is intended for
+'gnogenesis fork generate --migration-tx' as a prerequisite step
+when the source chain doesn't have a needed realm deployed.
+
+Example: forking from gnoland-1 (which doesn't have v3) to a chain
+that requires r/sys/validators/v3:
+
+  gnogenesis fork addpkg \
+      --output addpkg-v3.jsonl \
+      examples/gno.land/r/sys/validators/v3
+  gnogenesis fork generate \
+      --source ... \
+      --migration-tx addpkg-v3.jsonl \
+      --migration-tx valoper-seed.jsonl \
+      ...
+
+Each emitted tx is a MsgAddPackage with:
+  - Caller = --deployer (default: gnoland-1's test1 account)
+  - Package = LoadPackagesFromDir(<pkgdir>) — recursive, includes sub-realms
+  - Metadata.BlockHeight = 0 (genesis-mode)
+  - Signatures = [] (consumer runs with --skip-genesis-sig-verification)
+
+Output is written in the order packages are loaded; LoadPackagesFromDir
+sorts by pkgpath internally, so the same input produces a byte-equal
+output across runs.`,
+		},
+		cfg,
+		func(ctx context.Context, args []string) error {
+			return execAddpkg(ctx, cfg, io, args)
+		},
+	)
+}
+
+func (c *addpkgCfg) RegisterFlags(fs *flag.FlagSet) {
+	fs.StringVar(&c.output, "output", "", "output .jsonl path (required)")
+	fs.StringVar(&c.deployerStr, "deployer", defaultDeployerAddr,
+		"bech32 address that becomes the package owner; defaults to gnoland-1's test1 account")
+}
+
+func execAddpkg(_ context.Context, cfg *addpkgCfg, io commands.IO, args []string) error {
+	if cfg.output == "" {
+		return errors.New("--output is required")
+	}
+	if len(args) == 0 {
+		return errors.New("at least one pkgdir argument is required")
+	}
+
+	deployer, err := crypto.AddressFromBech32(cfg.deployerStr)
+	if err != nil {
+		return fmt.Errorf("invalid --deployer %q: %w", cfg.deployerStr, err)
+	}
+
+	var allTxs []gnoland.TxWithMetadata
+	for _, dir := range args {
+		txs, err := gnoland.LoadPackagesFromDir(dir, deployer, genesisDeployFee)
+		if err != nil {
+			return fmt.Errorf("LoadPackagesFromDir %q: %w", dir, err)
+		}
+		// Ensure each tx has Metadata.BlockHeight=0 explicitly,
+		// even though readMigrationTxs forces it at consume time —
+		// keeps the .jsonl self-describing.
+		for i := range txs {
+			if txs[i].Metadata == nil {
+				txs[i].Metadata = &gnoland.GnoTxMetadata{}
+			}
+			txs[i].Metadata.BlockHeight = 0
+			// Strip signatures: consumer runs with
+			// --skip-genesis-sig-verification.
+			txs[i].Tx.Signatures = []std.Signature{}
+		}
+		allTxs = append(allTxs, txs...)
+	}
+
+	var buf strings.Builder
+	for _, tx := range allTxs {
+		line, err := amino.MarshalJSON(tx)
+		if err != nil {
+			return fmt.Errorf("marshal tx: %w", err)
+		}
+		buf.Write(line)
+		buf.WriteByte('\n')
+	}
+
+	if err := os.WriteFile(cfg.output, []byte(buf.String()), 0o644); err != nil {
+		return fmt.Errorf("write %s: %w", cfg.output, err)
+	}
+
+	io.Printfln("wrote %d MsgAddPackage txs to %s", len(allTxs), cfg.output)
+	return nil
+}

contribs/gnogenesis/internal/fork/addpkg_test.go

@@ -0,0 +1,102 @@
+package fork
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/gnolang/gno/gno.land/pkg/gnoland"
+	"github.com/gnolang/gno/gno.land/pkg/sdk/vm"
+	"github.com/gnolang/gno/tm2/pkg/amino"
+	"github.com/gnolang/gno/tm2/pkg/commands"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// writePkg creates a minimal gno package on disk: gnomod.toml + a
+// single .gno file with the right package decl.
+func writePkg(t *testing.T, root, pkgPath, body string) string {
+	t.Helper()
+	dir := filepath.Join(root, pkgPath)
+	require.NoError(t, os.MkdirAll(dir, 0o755))
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "gnomod.toml"),
+		[]byte("module = \"gno.land/"+pkgPath+"\"\ngno = \"0.9\"\n"), 0o644))
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "main.gno"),
+		[]byte(body), 0o644))
+	return dir
+}
+
+func runAddpkg(t *testing.T, args ...string) (string, error) {
+	t.Helper()
+	dir := t.TempDir()
+	outPath := filepath.Join(dir, "out.jsonl")
+	cfg := &addpkgCfg{output: outPath, deployerStr: defaultDeployerAddr}
+	io := commands.NewTestIO()
+	if err := execAddpkg(t.Context(), cfg, io, args); err != nil {
+		return "", err
+	}
+	data, err := os.ReadFile(outPath)
+	require.NoError(t, err)
+	return string(data), nil
+}
+
+func TestAddpkg_HappyPath(t *testing.T) {
+	t.Parallel()
+	root := t.TempDir()
+	pkgDir := writePkg(t, root, "r/test/foo",
+		"package foo\n\nfunc Hello() string { return \"hi\" }\n")
+
+	out, err := runAddpkg(t, pkgDir)
+	require.NoError(t, err)
+
+	lines := strings.Split(strings.TrimRight(out, "\n"), "\n")
+	require.Len(t, lines, 1)
+
+	var tx gnoland.TxWithMetadata
+	require.NoError(t, amino.UnmarshalJSON([]byte(lines[0]), &tx))
+	require.Len(t, tx.Tx.Msgs, 1)
+	msg, ok := tx.Tx.Msgs[0].(vm.MsgAddPackage)
+	require.True(t, ok, "msg is MsgAddPackage")
+	assert.Equal(t, "gno.land/r/test/foo", msg.Package.Path)
+	assert.Equal(t, defaultDeployerAddr, msg.Creator.String())
+	require.NotNil(t, tx.Metadata)
+	assert.Equal(t, int64(0), tx.Metadata.BlockHeight)
+	assert.Empty(t, tx.Tx.Signatures, "signatures stripped (consumer skips sig verification)")
+}
+
+func TestAddpkg_MultiplePackages(t *testing.T) {
+	t.Parallel()
+	root := t.TempDir()
+	a := writePkg(t, root, "r/test/foo", "package foo\n")
+	b := writePkg(t, root, "r/test/bar", "package bar\n")
+
+	out, err := runAddpkg(t, a, b)
+	require.NoError(t, err)
+	lines := strings.Split(strings.TrimRight(out, "\n"), "\n")
+	require.Len(t, lines, 2)
+}
+
+func TestAddpkg_RejectsMissingOutput(t *testing.T) {
+	t.Parallel()
+	cfg := &addpkgCfg{output: "", deployerStr: defaultDeployerAddr}
+	err := execAddpkg(t.Context(), cfg, commands.NewTestIO(), []string{"/tmp/dummy"})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "--output is required")
+}
+
+func TestAddpkg_RejectsNoArgs(t *testing.T) {
+	t.Parallel()
+	cfg := &addpkgCfg{output: filepath.Join(t.TempDir(), "out.jsonl"), deployerStr: defaultDeployerAddr}
+	err := execAddpkg(t.Context(), cfg, commands.NewTestIO(), nil)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "at least one pkgdir")
+}
+
+func TestAddpkg_RejectsBadDeployer(t *testing.T) {
+	t.Parallel()
+	cfg := &addpkgCfg{output: filepath.Join(t.TempDir(), "out.jsonl"), deployerStr: "not-bech32"}
+	err := execAddpkg(t.Context(), cfg, commands.NewTestIO(), []string{"/tmp/dummy"})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "invalid --deployer")
+}

contribs/gnogenesis/internal/fork/fork.go

@@ -0,0 +1,52 @@
+// Package fork provides the `gnogenesis fork` subcommands for building and
+// smoke-testing hardfork genesis files.
+//
+// A hardfork genesis is built from:
+//  1. SOURCE CHAIN  — provides historical state (genesis + tx history)
+//  2. NEW BINARY    — the updated gnoland built from this repo
+//
+// Source modes (auto-detected from --source):
+//
+//	http(s)://...    RPC of a running or recently-halted node
+//	/path/to/dir     local node data directory (must contain config/genesis.json)
+//	/path/to/file    exported file: genesis.json (no txs) or .jsonl (txs) or .tar.gz
+package fork
+
+import (
+	"github.com/gnolang/gno/tm2/pkg/commands"
+)
+
+// NewForkCmd returns the `gnogenesis fork` parent command with its
+// subcommands (`generate`, `test`) attached.
+func NewForkCmd(io commands.IO) *commands.Command {
+	cmd := commands.NewCommand(
+		commands.Metadata{
+			Name:       "fork",
+			ShortUsage: "<subcommand> [flags] [<arg>...]",
+			ShortHelp:  "build and smoke-test hardfork genesis files",
+			LongHelp: `Build a hardfork genesis from a source chain and smoke-test it locally.
+
+Subcommands:
+  generate     Assemble a new-chain genesis.json from a source chain's state + tx history.
+  test         Run an in-memory InitChain replay against a genesis.json (fast smoke-test).
+  valoper-seed Build a deterministic .jsonl of valopers.Register migration txs from a CSV.
+  addpkg       Build a .jsonl of MsgAddPackage migration txs from local package dirs.
+
+Source modes (auto-detected from --source):
+  http(s)://...    RPC of a running or recently-halted node
+  /path/to/dir     local node data directory (must contain config/genesis.json)
+  /path/to/file    exported file: genesis.json (no txs) or .jsonl (txs) or .tar.gz`,
+		},
+		commands.NewEmptyConfig(),
+		commands.HelpExec,
+	)
+
+	cmd.AddSubCommands(
+		newGenerateCmd(io),
+		newTestCmd(io),
+		newValoperSeedCmd(io),
+		newAddpkgCmd(io),
+	)
+
+	return cmd
+}