feat: add p/sys/boot + codegen system for contracts

contribs/gnodev/cmd/gnodev/main.go

@@ -436,6 +436,12 @@ func resolvePackagesPathFromArgs(cfg *devCfg, bk *address.Book, args []string) (
 			Creator: defaultKey,
 			Deposit: nil,
 		})
+	} else {
+		paths = append(paths, gnodev.PackagePath{
+			Path:    filepath.Join(cfg.root, "examples", "gno.land", "p", "sys", "boot"),
+			Creator: defaultKey,
+			Deposit: nil,
+		})
 	}
 
 	return paths, nil

contribs/gnodev/pkg/dev/node_test.go

@@ -74,6 +74,42 @@ func Render(_ string) string { return "foo" }
 	require.NoError(t, node.Close())
 }
 
+func TestNewNode_tplData(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	const (
+		// foobar package
+		testGnoMod = "module gno.land/r/dev/foobar\n"
+		docFile    = `package foobar`
+		testFile   = `package foobar
+func Render(_ string) string { return "{{.}}" }
+`
+	)
+
+	// Generate package
+	pkgpath := generateTestingPackage(t,
+		"gno.mod", testGnoMod,
+		"foobar.gno.tpl", testFile,
+		"doc.gno", docFile,
+	)
+	logger := log.NewTestingLogger(t)
+
+	// Call NewDevNode with no package should work
+	cfg := DefaultNodeConfig(gnoenv.RootDir())
+	cfg.PackagesPathList = []PackagePath{pkgpath}
+	node, err := NewDevNode(ctx, logger, &emitter.NoopServer{}, cfg)
+	require.NoError(t, err)
+	assert.Len(t, node.ListPkgs(), 1)
+
+	// Test rendering
+	render, err := testingRenderRealm(t, node, "gno.land/r/dev/foobar")
+	require.NoError(t, err)
+	assert.Equal(t, render, "foo")
+
+	require.NoError(t, node.Close())
+}
+
 func TestNodeAddPackage(t *testing.T) {
 	// Setup a Node instance
 	const (

contribs/gnodev/pkg/dev/packages.go

@@ -7,9 +7,11 @@ import (
 	"path/filepath"
 
 	"github.com/gnolang/gno/contribs/gnodev/pkg/address"
-	vmm "github.com/gnolang/gno/gno.land/pkg/sdk/vm"
+	"github.com/gnolang/gno/gno.land/pkg/gnoland"
+	"github.com/gnolang/gno/gno.land/pkg/sdk/vm"
 	gno "github.com/gnolang/gno/gnovm/pkg/gnolang"
 	"github.com/gnolang/gno/gnovm/pkg/gnomod"
+	"github.com/gnolang/gno/tm2/pkg/amino"
 	"github.com/gnolang/gno/tm2/pkg/crypto"
 	"github.com/gnolang/gno/tm2/pkg/std"
 )
@@ -128,6 +130,9 @@ func (pm PackagesMap) Load(fee std.Fee) ([]std.Tx, error) {
 
 	nonDraft := sorted.GetNonDraftPkgs()
 	txs := []std.Tx{}
+
+	tplData := gnoland.GenesisTplData{}
+
 	for _, modPkg := range nonDraft {
 		pkg := pm[modPkg.Dir]
 		if pkg.Creator.IsZero() {
@@ -136,23 +141,22 @@ func (pm PackagesMap) Load(fee std.Fee) ([]std.Tx, error) {
 
 		// Open files in directory as MemPackage.
 		memPkg := gno.ReadMemPackage(modPkg.Dir, modPkg.Name)
-		if err := memPkg.Validate(); err != nil {
-			return nil, fmt.Errorf("invalid package: %w", err)
+		for _, file := range memPkg.Files {
+			fmt.Printf("BBB: %q, %s\n", file.Name, file.Body)
+		}
+
+		tx, err := gnoland.LoadPackage(memPkg, pkg.Creator, fee, pkg.Deposit, tplData)
+		if err != nil {
+			return nil, err
 		}
 
-		// Create transaction
-		tx := std.Tx{
-			Fee: fee,
-			Msgs: []std.Msg{
-				vmm.MsgAddPackage{
-					Creator: pkg.Creator,
-					Deposit: pkg.Deposit,
-					Package: memPkg,
-				},
-			},
+		var msg vm.MsgAddPackage
+		bz := tx.Msgs[0].GetSignBytes()
+		amino.MustUnmarshalJSON(bz, &msg)
+		for _, file := range msg.Package.Files {
+			fmt.Printf("AAA: %q, %s\n", file.Name, file.Body)
 		}
 
-		tx.Signatures = make([]std.Signature, len(tx.GetSigners()))
 		txs = append(txs, tx)
 	}
 

examples/gno.land/p/sys/boot/doc.gno

@@ -0,0 +1,14 @@
+// the boot package is similar to linux' /boot/cmdline.
+//
+// it contains values that were used to initialize the chain. as a pure-package,
+// its content is immutable, which makes this package having a high potential of
+// quickly becoming outdated. however, it can be used safely by initial
+// contracts' init() functions.
+//
+// per-context expected usages:
+// - gnodev:
+//   - register current node's on poa
+//   - dynamically load local gnokey's information
+//
+// - gnoland: static file manually patched by the chain architects.
+package boot

examples/gno.land/p/sys/boot/gen.gno.tpl

@@ -0,0 +1,5 @@
+package boot
+
+/*
+  {{.}}
+*/

examples/gno.land/p/sys/boot/gno.mod

@@ -0,0 +1 @@
+module gno.land/p/sys/boot

gno.land/cmd/gnoland/genesis_txs_add_packages.go

@@ -52,9 +52,10 @@ func execTxsAddPackages(
 	}
 
 	parsedTxs := make([]std.Tx, 0)
+	tplData := gnoland.GenesisTplData{}
 	for _, path := range args {
 		// Generate transactions from the packages (recursively)
-		txs, err := gnoland.LoadPackagesFromDir(path, genesisDeployAddress, genesisDeployFee)
+		txs, err := gnoland.LoadPackagesFromDir(path, genesisDeployAddress, genesisDeployFee, tplData)
 		if err != nil {
 			return fmt.Errorf("unable to load txs from directory, %w", err)
 		}

gno.land/cmd/gnoland/start.go

@@ -400,7 +400,8 @@ func generateGenesisFile(genesisFile string, pk crypto.PubKey, c *startCfg) erro
 
 	// Load examples folder
 	examplesDir := filepath.Join(c.gnoRootDir, "examples")
-	pkgsTxs, err := gnoland.LoadPackagesFromDir(examplesDir, genesisDeployAddress, genesisDeployFee)
+	tplData := gnoland.GenesisTplData{}
+	pkgsTxs, err := gnoland.LoadPackagesFromDir(examplesDir, genesisDeployAddress, genesisDeployFee, tplData)
 	if err != nil {
 		return fmt.Errorf("unable to load examples folder: %w", err)
 	}

gno.land/pkg/gnoland/genesis.go

@@ -1,15 +1,18 @@
 package gnoland
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"strings"
+	"text/template"
 
 	vmm "github.com/gnolang/gno/gno.land/pkg/sdk/vm"
 	gno "github.com/gnolang/gno/gnovm/pkg/gnolang"
 	"github.com/gnolang/gno/gnovm/pkg/gnomod"
 	"github.com/gnolang/gno/tm2/pkg/amino"
+	"github.com/gnolang/gno/tm2/pkg/bft/types"
 	bft "github.com/gnolang/gno/tm2/pkg/bft/types"
 	"github.com/gnolang/gno/tm2/pkg/crypto"
 	osm "github.com/gnolang/gno/tm2/pkg/os"
 	"github.com/gnolang/gno/tm2/pkg/std"
@@ -86,9 +89,9 @@
 
 // LoadPackagesFromDir loads gno packages from a directory.
 // It creates and returns a list of transactions based on these packages.
-func LoadPackagesFromDir(dir string, creator bft.Address, fee std.Fee) ([]std.Tx, error) {
+func LoadPackagesFromDir(dir string, creator bft.Address, fee std.Fee, genData GenesisTplData) ([]std.Tx, error) {
 	// list all packages from target path
-	pkgs, err := gnomod.ListPkgs(dir)
+	pkgs, err := gnomod.ListPkgs(dir) // XXX: gnomod isn't maanaging packages but modules
 	if err != nil {
 		return nil, fmt.Errorf("listing gno packages: %w", err)
 	}
@@ -103,7 +106,8 @@
 	nonDraftPkgs := sortedPkgs.GetNonDraftPkgs()
 	txs := []std.Tx{}
 	for _, pkg := range nonDraftPkgs {
-		tx, err := LoadPackage(pkg, creator, fee, nil)
+		memPkg := gno.ReadMemPackage(pkg.Dir, pkg.Name, genData)
+		tx, err := LoadPackage(memPkg, creator, fee, nil, genData)
 		if err != nil {
 			return nil, fmt.Errorf("unable to load package %q: %w", pkg.Dir, err)
 		}
@@ -115,16 +119,31 @@
 }
 
 // LoadPackage loads a single package into a `std.Tx`
-func LoadPackage(pkg gnomod.Pkg, creator bft.Address, fee std.Fee, deposit std.Coins) (std.Tx, error) {
+func LoadPackage(memPkg *std.MemPackage, creator bft.Address, fee std.Fee, deposit std.Coins, genData GenesisTplData) (std.Tx, error) {
 	var tx std.Tx
 
 	// Open files in directory as MemPackage.
-	memPkg := gno.ReadMemPackage(pkg.Dir, pkg.Name)
 	err := memPkg.Validate()
 	if err != nil {
 		return tx, fmt.Errorf("invalid package: %w", err)
 	}
 
+	// Codegen (.tpl)
+	for _, file := range memPkg.Files {
+		if strings.HasSuffix(file.Name, ".tpl") {
+			file.Name = strings.TrimSuffix(file.Name, ".tpl")
+			var tpl = template.Must(template.New(file.Name).Parse(file.Body))
+			var buf bytes.Buffer
+			if err := tpl.Execute(&buf, genData); err != nil {
+				return std.Tx{}, err
+			}
+			file.Body = buf.String()
+			if strings.HasSuffix(file.Name, ".gno") {
+				file.Body = "// Code generated by gnoland; DO NOT EDIT.\n" + file.Body
+			}
+		}
+	}
+
 	// Create transaction
 	tx.Fee = fee
 	tx.Msgs = []std.Msg{
@@ -138,3 +157,10 @@
 
 	return tx, nil
 }
+
+type GenesisTplData struct {
+	Genesis types.GenesisDoc
+	// LocalGnokey
+	// BuildTags
+	// -X
+}

gno.land/pkg/gnoland/genesis_test.go

@@ -0,0 +1,47 @@
+package gnoland
+
+import (
+	"testing"
+
+	"github.com/gnolang/gno/gno.land/pkg/sdk/vm"
+	"github.com/gnolang/gno/tm2/pkg/amino"
+	bft "github.com/gnolang/gno/tm2/pkg/bft/types"
+	"github.com/gnolang/gno/tm2/pkg/std"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLoadPackagesFromDir(t *testing.T) {
+	var (
+		memPkg = &std.MemPackage{
+			Name: "foo",
+			Path: "gno.land/r/demo/foo",
+			Files: []*std.MemFile{
+				{Name: "empty.gno", Body: "package foo"},
+				{Name: "generated.gno.tpl", Body: `package foo
+
+var ChainID = {{.Genesis.ChainID | printf "%q"}}
+`},
+			},
+		}
+		creator = bft.Address{}
+		fee     = std.Fee{}
+		deposit = std.Coins{}
+	)
+	tplData := GenesisTplData{}
+	tplData.Genesis.ChainID = "test"
+	tx, err := LoadPackage(memPkg, creator, fee, deposit, tplData)
+	assert.NoError(t, err)
+	var msg vm.MsgAddPackage
+	bz := tx.Msgs[0].GetSignBytes()
+	amino.MustUnmarshalJSON(bz, &msg)
+	for _, file := range msg.Package.Files {
+		assert.NotEqual(t, "generated.gno.tpl", file.Name, "*.tpl files should be removed")
+		if file.Name == "generated.gno.tpl" {
+			expected := `package foo
+
+var ChainID = "test"
+`
+			assert.Equal(t, expected, file.Body)
+		}
+	}
+}

gno.land/pkg/integration/testing_integration.go

@@ -16,6 +16,7 @@ import (
 	"github.com/gnolang/gno/gno.land/pkg/keyscli"
 	"github.com/gnolang/gno/gno.land/pkg/log"
 	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
+	gno "github.com/gnolang/gno/gnovm/pkg/gnolang"
 	"github.com/gnolang/gno/gnovm/pkg/gnomod"
 	"github.com/gnolang/gno/tm2/pkg/bft/node"
 	bft "github.com/gnolang/gno/tm2/pkg/bft/types"
@@ -595,8 +596,11 @@ func (pl *pkgsLoader) LoadPackages(creator bft.Address, fee std.Fee, deposit std
 	}
 
 	txs := make([]std.Tx, len(pkgslist))
+	tplData := gnoland.GenesisTplData{}
 	for i, pkg := range pkgslist {
-		tx, err := gnoland.LoadPackage(pkg, creator, fee, deposit)
+		genData := gnoland.GenesisTplData{}
+		memPkg := gno.ReadMemPackage(pkg.Dir, pkg.Name, genData)
+		tx, err := gnoland.LoadPackage(memPkg, creator, fee, deposit, tplData)
 		if err != nil {
 			return nil, fmt.Errorf("unable to load pkg %q: %w", pkg.Name, err)
 		}

gno.land/pkg/integration/testing_node.go

@@ -48,8 +48,9 @@
 	creator := crypto.MustAddressFromString(DefaultAccount_Address) // test1
 
 	balances := LoadDefaultGenesisBalanceFile(t, gnoroot)
+	tplData := DefaultGenesisTplData()
 	txs := []std.Tx{}
-	txs = append(txs, LoadDefaultPackages(t, creator, gnoroot)...)
+	txs = append(txs, LoadDefaultPackages(t, creator, gnoroot, tplData)...)
 	txs = append(txs, LoadDefaultGenesisTXsFile(t, cfg.Genesis.ChainID, gnoroot)...)
 
 	cfg.Genesis.AppState = gnoland.GnoGenesisState{
@@ -60,6 +61,11 @@
 	return cfg, creator
 }
 
+func DefaultGenesisTplData() gnoland.GenesisTplData {
+	tplData := gnoland.GenesisTplData{}
+	return tplData
+}
+
 // TestingMinimalNodeConfig constructs the default minimal in-memory node configuration for testing.
 func TestingMinimalNodeConfig(t TestingTS, gnoroot string) *gnoland.InMemoryNodeConfig {
 	tmconfig := DefaultTestingTMConfig(gnoroot)
@@ -111,11 +117,11 @@
 }
 
 // LoadDefaultPackages loads the default packages for testing using a given creator address and gnoroot directory.
-func LoadDefaultPackages(t TestingTS, creator bft.Address, gnoroot string) []std.Tx {
+func LoadDefaultPackages(t TestingTS, creator bft.Address, gnoroot string, tplData gnoland.GenesisTplData) []std.Tx {
 	examplesDir := filepath.Join(gnoroot, "examples")
 
 	defaultFee := std.NewFee(50000, std.MustParseCoin("1000000ugnot"))
-	txs, err := gnoland.LoadPackagesFromDir(examplesDir, creator, defaultFee)
+	txs, err := gnoland.LoadPackagesFromDir(examplesDir, creator, defaultFee, tplData)
 	require.NoError(t, err)
 
 	return txs

gno.land/pkg/keyscli/addpkg.go

@@ -96,7 +96,8 @@ func execMakeAddPkg(cfg *MakeAddPkgCfg, args []string, io commands.IO) error {
 	}
 
 	// open files in directory as MemPackage.
-	memPkg := gno.ReadMemPackage(cfg.PkgDir, cfg.PkgPath)
+	var genData interface{} = nil
+	memPkg := gno.ReadMemPackage(cfg.PkgDir, cfg.PkgPath, genData)
 	if memPkg.IsEmpty() {
 		panic(fmt.Sprintf("found an empty package %q", cfg.PkgPath))
 	}

gno.land/pkg/keyscli/run.go

@@ -91,7 +91,8 @@
 			return fmt.Errorf("could not read source path: %q, %w", sourcePath, err)
 		}
 		if info.IsDir() {
-			memPkg = gno.ReadMemPackage(sourcePath, "")
+			var genData interface{} = nil
+			memPkg = gno.ReadMemPackage(sourcePath, "", genData)
 		} else { // is file
 			b, err := os.ReadFile(sourcePath)
 			if err != nil {

gno.land/pkg/sdk/vm/builtins.go

@@ -25,7 +25,8 @@ func (vm *VMKeeper) getPackage(pkgPath string, store gno.Store) (pn *gno.Package
 		// does not exist.
 		return nil, nil
 	}
-	memPkg := gno.ReadMemPackage(stdlibPath, pkgPath)
+	var genData interface{} = nil
+	memPkg := gno.ReadMemPackage(stdlibPath, pkgPath, genData)
 	if memPkg.IsEmpty() {
 		// no gno files are present, skip this package
 		return nil, nil