feat: move standard library initialization to genesis transactions

contribs/gnodev/pkg/dev/node.go

@@ -17,6 +17,7 @@ import (
 	"github.com/gnolang/gno/gno.land/pkg/gnoland/ugnot"
 	"github.com/gnolang/gno/gno.land/pkg/integration"
 	"github.com/gnolang/gno/gnovm/pkg/gnomod"
+	"github.com/gnolang/gno/gnovm/stdlibs"
 	"github.com/gnolang/gno/tm2/pkg/amino"
 	tmcfg "github.com/gnolang/gno/tm2/pkg/bft/config"
 	"github.com/gnolang/gno/tm2/pkg/bft/node"
@@ -98,6 +99,9 @@ type Node struct {
 var DefaultFee = std.NewFee(50000, std.MustParseCoin(ugnot.ValueString(1000000)))
 
 func NewDevNode(ctx context.Context, cfg *NodeConfig) (*Node, error) {
+	stdlibsDeployer := crypto.MustAddressFromString("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") // test1, FIXME: replace
+	stdlibsTxs := gnoland.LoadEmbeddedStdlibs(stdlibsDeployer, DefaultFee)
+
 	mpkgs, err := NewPackagesMap(cfg.PackagesPathList)
 	if err != nil {
 		return nil, fmt.Errorf("unable map pkgs list: %w", err)
@@ -126,7 +130,7 @@ func NewDevNode(ctx context.Context, cfg *NodeConfig) (*Node, error) {
 	// generate genesis state
 	genesis := gnoland.GnoGenesisState{
 		Balances: cfg.BalancesList,
-		Txs:      append(pkgsTxs, cfg.InitialTxs...),
+		Txs:      append(stdlibsTxs, append(pkgsTxs, cfg.InitialTxs...)...),
 	}
 
 	if err := devnode.rebuildNode(ctx, genesis); err != nil {
@@ -280,14 +284,18 @@ func (n *Node) Reset(ctx context.Context) error {
 	// Reset starting time
 	startTime := time.Now()
 
+	// Load stdlibs
+	stdlibsDeployer := crypto.MustAddressFromString("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") // test1, FIXME: replace
+	stdlibsTxs := gnoland.LoadEmbeddedStdlibs(stdlibsDeployer, DefaultFee)
+
 	// Generate a new genesis state based on the current packages
 	pkgsTxs, err := n.pkgs.Load(DefaultFee, startTime)
 	if err != nil {
 		return fmt.Errorf("unable to load pkgs: %w", err)
 	}
 
 	// Append initialTxs
-	txs := append(pkgsTxs, n.initialState...)
+	txs := append(stdlibsTxs, append(pkgsTxs, n.initialState...)...)
 	genesis := gnoland.GnoGenesisState{
 		Balances: n.config.BalancesList,
 		Txs:      txs,
@@ -370,7 +378,9 @@ func (n *Node) getBlockStoreState(ctx context.Context) ([]gnoland.TxWithMetadata
 	// get current genesis state
 	genesis := n.GenesisDoc().AppState.(gnoland.GnoGenesisState)
 
-	initialTxs := genesis.Txs[n.loadedPackages:] // ignore previously loaded packages
+	numStdLibs := len(stdlibs.InitOrder()) - 1              // stdlibs count minus testing lib
+	initialTxs := genesis.Txs[n.loadedPackages+numStdLibs:] // ignore previously loaded packages
+
 	state := append([]gnoland.TxWithMetadata{}, initialTxs...)
 
 	lastBlock := n.getLatestBlockNumber()
@@ -491,8 +501,6 @@ func (n *Node) rebuildNode(ctx context.Context, genesis gnoland.GnoGenesisState)
 	// Setup node config
 	nodeConfig := newNodeConfig(n.config.TMConfig, n.config.ChainID, n.config.ChainDomain, genesis)
 	nodeConfig.GenesisTxResultHandler = n.genesisTxResultHandler
-	// 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
 
 	// recoverFromError handles panics and converts them to errors.

contribs/gnodev/pkg/dev/node_state.go

@@ -8,6 +8,7 @@ import (
 	"github.com/gnolang/gno/contribs/gnodev/pkg/events"
 	"github.com/gnolang/gno/gno.land/pkg/gnoland"
 	bft "github.com/gnolang/gno/tm2/pkg/bft/types"
+	"github.com/gnolang/gno/tm2/pkg/crypto"
 )
 
 var ErrEmptyState = errors.New("empty state")
@@ -83,6 +84,10 @@ func (n *Node) MoveBy(ctx context.Context, x int) error {
 		return nil
 	}
 
+	// Load stdlibs
+	stdlibsDeployer := crypto.MustAddressFromString("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5") // test1, FIXME: replace
+	stdlibsTxs := gnoland.LoadEmbeddedStdlibs(stdlibsDeployer, DefaultFee)
+
 	// Load genesis packages
 	pkgsTxs, err := n.pkgs.Load(DefaultFee, n.startTime)
 	if err != nil {
@@ -94,7 +99,7 @@ func (n *Node) MoveBy(ctx context.Context, x int) error {
 	// Create genesis with loaded pkgs + previous state
 	genesis := gnoland.GnoGenesisState{
 		Balances: n.config.BalancesList,
-		Txs:      append(pkgsTxs, newState...),
+		Txs:      append(stdlibsTxs, append(pkgsTxs, newState...)...),
 	}
 
 	// Reset the node with the new genesis state.

contribs/gnodev/pkg/dev/node_state_test.go

@@ -192,7 +192,7 @@ func Render(_ string) string { return strconv.Itoa(value) }
 func testingContext(t *testing.T) context.Context {
 	t.Helper()
 
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*7)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
 	t.Cleanup(cancel)
 	return ctx
 }

contribs/gnodev/pkg/dev/packages.go

@@ -139,7 +139,7 @@ func (pm PackagesMap) Load(fee std.Fee, start time.Time) ([]gnoland.TxWithMetada
 
 		// Open files in directory as MemPackage.
 		memPkg := gno.MustReadMemPackage(modPkg.Dir, modPkg.Name)
-		if err := memPkg.Validate(); err != nil {
+		if err := memPkg.Validate(true); err != nil {
 			return nil, fmt.Errorf("invalid package: %w", err)
 		}
 

gno.land/cmd/gnoland/start.go

@@ -394,6 +394,9 @@ func generateGenesisFile(genesisFile string, pk crypto.PubKey, c *startCfg) erro
 		return fmt.Errorf("unable to load genesis balances file %q: %w", c.genesisBalancesFile, err)
 	}
 
+	// Load embedded stdlibs
+	stdlibsTxs := gnoland.LoadEmbeddedStdlibs(genesisDeployAddress, genesisDeployFee)
+
 	// Load examples folder
 	examplesDir := filepath.Join(c.gnoRootDir, "examples")
 	pkgsTxs, err := gnoland.LoadPackagesFromDir(examplesDir, genesisDeployAddress, genesisDeployFee)
@@ -407,7 +410,7 @@ func generateGenesisFile(genesisFile string, pk crypto.PubKey, c *startCfg) erro
 		return fmt.Errorf("unable to load genesis txs file: %w", err)
 	}
 
-	genesisTxs = append(pkgsTxs, genesisTxs...)
+	genesisTxs = append(stdlibsTxs, append(pkgsTxs, genesisTxs...)...)
 
 	// Construct genesis AppState.
 	gen.AppState = gnoland.GnoGenesisState{

gno.land/cmd/gnoland/start_test.go

@@ -116,7 +116,7 @@ func TestStart_Lazy(t *testing.T) {
 	io.SetErr(commands.WriteNopCloser(mockErr))
 
 	// Create and run the command
-	ctx, cancelFn := context.WithTimeout(context.Background(), 10*time.Second)
+	ctx, cancelFn := context.WithTimeout(context.Background(), 20*time.Second)
 	defer cancelFn()
 
 	// Set up the command ctx
@@ -128,7 +128,7 @@ func TestStart_Lazy(t *testing.T) {
 	})
 
 	// Set up the retry ctx
-	retryCtx, retryCtxCancelFn := context.WithTimeout(ctx, 5*time.Second)
+	retryCtx, retryCtxCancelFn := context.WithTimeout(ctx, 10*time.Second)
 	defer retryCtxCancelFn()
 
 	// This is a very janky way to verify the node has started.

gno.land/pkg/gnoland/app.go

@@ -10,7 +10,6 @@ import (
 	"time"
 
 	"github.com/gnolang/gno/gno.land/pkg/sdk/vm"
-	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
 	abci "github.com/gnolang/gno/tm2/pkg/bft/abci/types"
 	"github.com/gnolang/gno/tm2/pkg/bft/config"
 	bft "github.com/gnolang/gno/tm2/pkg/bft/types"
@@ -50,8 +49,6 @@ func TestAppOptions(db dbm.DB) *AppOptions {
 		EventSwitch: events.NewEventSwitch(),
 		InitChainerConfig: InitChainerConfig{
 			GenesisTxResultHandler: PanicOnFailingTxResultHandler,
-			StdlibDir:              filepath.Join(gnoenv.RootDir(), "gnovm", "stdlibs"),
-			CacheStdlibLoad:        true,
 		},
 	}
 }
@@ -183,7 +180,6 @@ func NewApp(
 		EventSwitch: evsw,
 		InitChainerConfig: InitChainerConfig{
 			GenesisTxResultHandler: PanicOnFailingTxResultHandler,
-			StdlibDir:              filepath.Join(gnoenv.RootDir(), "gnovm", "stdlibs"),
 		},
 	}
 	if skipFailingGenesisTxs {
@@ -221,14 +217,6 @@ type InitChainerConfig struct {
 	// Handles the results of each genesis transaction.
 	GenesisTxResultHandler
 
-	// Standard library directory.
-	StdlibDir string
-	// Whether to keep a record of the DB operations to load standard libraries,
-	// so they can be quickly replicated on additional genesis executions.
-	// This should be used for integration testing, where InitChainer will be
-	// called several times.
-	CacheStdlibLoad bool
-
 	// These fields are passed directly by NewAppWithOptions, and should not be
 	// configurable by end-users.
 	baseApp   *sdk.BaseApp
@@ -243,12 +231,6 @@ func (cfg InitChainerConfig) InitChainer(ctx sdk.Context, req abci.RequestInitCh
 	start := time.Now()
 	ctx.Logger().Debug("InitChainer: started")
 
-	// load standard libraries; immediately committed to store so that they are
-	// available for use when processing the genesis transactions below.
-	cfg.loadStdlibs(ctx)
-	ctx.Logger().Debug("InitChainer: standard libraries loaded",
-		"elapsed", time.Since(start))
-
 	// load app state. AppState may be nil mostly in some minimal testing setups;
 	// so log a warning when that happens.
 	txResponses, err := cfg.loadAppState(ctx, req.AppState)
@@ -270,24 +252,6 @@ func (cfg InitChainerConfig) InitChainer(ctx sdk.Context, req abci.RequestInitCh
 	}
 }
 
-func (cfg InitChainerConfig) loadStdlibs(ctx sdk.Context) {
-	// cache-wrapping is necessary for non-validator nodes; in the tm2 BaseApp,
-	// this is done using BaseApp.cacheTxContext; so we replicate it here.
-	ms := ctx.MultiStore()
-	msCache := ms.MultiCacheWrap()
-
-	stdlibCtx := cfg.vmKpr.MakeGnoTransactionStore(ctx)
-	stdlibCtx = stdlibCtx.WithMultiStore(msCache)
-	if cfg.CacheStdlibLoad {
-		cfg.vmKpr.LoadStdlibCached(stdlibCtx, cfg.StdlibDir)
-	} else {
-		cfg.vmKpr.LoadStdlib(stdlibCtx, cfg.StdlibDir)
-	}
-	cfg.vmKpr.CommitGnoTransactionStore(stdlibCtx)
-
-	msCache.MultiWrite()
-}
-
 func (cfg InitChainerConfig) loadAppState(ctx sdk.Context, appState any) ([]abci.ResponseDeliverTx, error) {
 	state, ok := appState.(GnoGenesisState)
 	if !ok {
@@ -351,6 +315,10 @@ func (cfg InitChainerConfig) loadAppState(ctx sdk.Context, appState any) ([]abci
 			GasUsed:      res.GasUsed,
 		})
 
+		if res.IsErr() {
+			fmt.Println("failed to exec genesis tx, height", ctx.BlockHeight(), "tx", stdTx, "res", res)
+		}
+
 		cfg.GenesisTxResultHandler(ctx, stdTx, res)
 	}
 	return txResponses, nil

gno.land/pkg/gnoland/app_test.go

@@ -1,7 +1,6 @@
 package gnoland
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"strings"
@@ -20,9 +19,6 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/log"
 	"github.com/gnolang/gno/tm2/pkg/sdk"
 	"github.com/gnolang/gno/tm2/pkg/std"
-	"github.com/gnolang/gno/tm2/pkg/store"
-	"github.com/gnolang/gno/tm2/pkg/store/dbadapter"
-	"github.com/gnolang/gno/tm2/pkg/store/iavl"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -147,87 +143,6 @@ func TestNewApp(t *testing.T) {
 	assert.True(t, resp.IsOK(), "resp is not OK: %v", resp)
 }
 
-// Test whether InitChainer calls to load the stdlibs correctly.
-func TestInitChainer_LoadStdlib(t *testing.T) {
-	t.Parallel()
-
-	t.Run("cached", func(t *testing.T) { testInitChainerLoadStdlib(t, true) })
-	t.Run("uncached", func(t *testing.T) { testInitChainerLoadStdlib(t, false) })
-}
-
-func testInitChainerLoadStdlib(t *testing.T, cached bool) { //nolint:thelper
-	t.Parallel()
-
-	type gsContextType string
-	const (
-		stdlibDir                   = "test-stdlib-dir"
-		gnoStoreKey   gsContextType = "gno-store-key"
-		gnoStoreValue gsContextType = "gno-store-value"
-	)
-	db := memdb.NewMemDB()
-	ms := store.NewCommitMultiStore(db)
-	baseCapKey := store.NewStoreKey("baseCapKey")
-	iavlCapKey := store.NewStoreKey("iavlCapKey")
-
-	ms.MountStoreWithDB(baseCapKey, dbadapter.StoreConstructor, db)
-	ms.MountStoreWithDB(iavlCapKey, iavl.StoreConstructor, db)
-	ms.LoadLatestVersion()
-	testCtx := sdk.NewContext(sdk.RunTxModeDeliver, ms.MultiCacheWrap(), &bft.Header{ChainID: "test-chain-id"}, log.NewNoopLogger())
-
-	// mock set-up
-	var (
-		makeCalls             int
-		commitCalls           int
-		loadStdlibCalls       int
-		loadStdlibCachedCalls int
-	)
-	containsGnoStore := func(ctx sdk.Context) bool {
-		return ctx.Context().Value(gnoStoreKey) == gnoStoreValue
-	}
-	// ptr is pointer to either loadStdlibCalls or loadStdlibCachedCalls
-	loadStdlib := func(ptr *int) func(ctx sdk.Context, dir string) {
-		return func(ctx sdk.Context, dir string) {
-			assert.Equal(t, stdlibDir, dir, "stdlibDir should match provided dir")
-			assert.True(t, containsGnoStore(ctx), "should contain gno store")
-			*ptr++
-		}
-	}
-	mock := &mockVMKeeper{
-		makeGnoTransactionStoreFn: func(ctx sdk.Context) sdk.Context {
-			makeCalls++
-			assert.False(t, containsGnoStore(ctx), "should not already contain gno store")
-			return ctx.WithContext(context.WithValue(ctx.Context(), gnoStoreKey, gnoStoreValue))
-		},
-		commitGnoTransactionStoreFn: func(ctx sdk.Context) {
-			commitCalls++
-			assert.True(t, containsGnoStore(ctx), "should contain gno store")
-		},
-		loadStdlibFn:       loadStdlib(&loadStdlibCalls),
-		loadStdlibCachedFn: loadStdlib(&loadStdlibCachedCalls),
-	}
-
-	// call initchainer
-	cfg := InitChainerConfig{
-		StdlibDir:       stdlibDir,
-		vmKpr:           mock,
-		CacheStdlibLoad: cached,
-	}
-	cfg.InitChainer(testCtx, abci.RequestInitChain{
-		AppState: GnoGenesisState{},
-	})
-
-	// assert number of calls
-	assert.Equal(t, 1, makeCalls, "should call MakeGnoTransactionStore once")
-	assert.Equal(t, 1, commitCalls, "should call CommitGnoTransactionStore once")
-	if cached {
-		assert.Equal(t, 0, loadStdlibCalls, "should call LoadStdlib never")
-		assert.Equal(t, 1, loadStdlibCachedCalls, "should call LoadStdlibCached once")
-	} else {
-		assert.Equal(t, 1, loadStdlibCalls, "should call LoadStdlib once")
-		assert.Equal(t, 0, loadStdlibCachedCalls, "should call LoadStdlibCached never")
-	}
-}
-
 // generateValidatorUpdates generates dummy validator updates
 func generateValidatorUpdates(t *testing.T, count int) []abci.ValidatorUpdate {
 	t.Helper()
@@ -287,30 +202,31 @@ func TestInitChainer_MetadataTxs(t *testing.T) {
 	var (
 		currentTimestamp = time.Now()
 		laterTimestamp   = currentTimestamp.Add(10 * 24 * time.Hour) // 10 days
+		stdlibsDeployFee = std.NewFee(50000, std.NewCoin("ugnot", 1000000))
 
 		getMetadataState = func(tx std.Tx, balances []Balance) GnoGenesisState {
+			stdlibs := LoadEmbeddedStdlibs(balances[0].Address, stdlibsDeployFee)
+
 			return GnoGenesisState{
 				// Set the package deployment as the genesis tx
-				Txs: []TxWithMetadata{
-					{
-						Tx: tx,
-						Metadata: &GnoTxMetadata{
-							Timestamp: laterTimestamp.Unix(),
-						},
+				Txs: append(stdlibs, TxWithMetadata{
+					Tx: tx,
+					Metadata: &GnoTxMetadata{
+						Timestamp: laterTimestamp.Unix(),
 					},
-				},
+				}),
 				// Make sure the deployer account has a balance
 				Balances: balances,
 			}
 		}
 
 		getNonMetadataState = func(tx std.Tx, balances []Balance) GnoGenesisState {
+			stdlibs := LoadEmbeddedStdlibs(balances[0].Address, stdlibsDeployFee)
+
 			return GnoGenesisState{
-				Txs: []TxWithMetadata{
-					{
-						Tx: tx,
-					},
-				},
+				Txs: append(stdlibs, TxWithMetadata{
+					Tx: tx,
+				}),
 				Balances: balances,
 			}
 		}
@@ -396,7 +312,7 @@ func TestInitChainer_MetadataTxs(t *testing.T) {
 					{
 						// Make sure the deployer account has a balance
 						Address: key.PubKey().Address(),
-						Amount:  std.NewCoins(std.NewCoin("ugnot", 20_000_000)),
+						Amount:  std.NewCoins(std.NewCoin("ugnot", 20_000_000_000)),
 					},
 				}),
 			})