fix(gno.land): make gno store cache respect rollbacks (#2319)

This pull request modifies the current `defaultStore` to support
transactionality in the same way as our tm2 stores. A few new concepts
are introduced:

- A `TransactionStore` interface is added, which extends the
`gnolang.Store` interface to support a Write() method.
- Together with corresponding implementations allowing for
transactionality on its cache maps, this means that the Gno store
retained by the VM keeper is only modified atomically after a
transaction has completed.
- The tm2 `BaseApp` has the new "hooks" `BeginTxHook` and `EndTxHook`.
The former is called right before starting a transaction, and the latter
is called right after finishing it, together with the transaction
result.
- This allows us to plug in the Gno `TransactionalStore` in the
`sdk.Context` through the `BeginTxHook`; and commit the result, if
successful, in the `EndTxHook`.
## Overview of changes

- `gno.land`
- `pkg/gnoland/app.go`: the InitChainer is now additionally responsible
of loading standard libraries. To separate the options related to app
startup globally, and those to genesis, the InitChainer is now a method
of its config struct, `InitChainerConfig`, embedded into the
`AppOptions`.
- `pkg/gnoland/app.go`: `NewAppOptions` is only used in `NewApp`, where
most of its fields were modified, anyway. I replaced it by changing the
`validate()` method to write default values.
- `pkg/gnoland/node_inmemory.go`,
`pkg/integration/testing_integration.go`: these changes were made
necessary to support `gnoland restart` in our txtars, and supporting
fast reloading of standard libraries (`LoadStdlibCached`).
- `pkg/sdk/vm/keeper.go`: removed all the code to load standard
libraries on Initialize, as it's now done in the InitChainer. The hack
introduced in #2568 is no longer necessary as well. Other changes show
how the Gno Store is injected and retrieved from the `sdk.Context`.
- `gnovm/pkg/gnolang/store.go`
- Fork and SwapStores have been removed, in favour of BeginTransaction.
BeginTransaction creates a `TransactionalStore`; the
"transaction-scoped" fields of the defaultStore are swapped with
"transactional" versions (including the allocator, cacheObjects and
cacheTypes/cacheNodes - the latter write to a `txLogMap`).
- ClearObjectCache is still necessary for the case of a transaction with
multiple messages.
- The `Map` interface in `txlog` allows us to have a `txLog` data type
stacked on top of another. This is useful for the cases where we use
`BeginTransaction` in preprocess. (We previously used `Fork`.) See later
in the "open questions" section.
- I added an Iterator method on the `txlog.Map` interface - this will be
compatible with [RangeFunc](https://go.dev/wiki/RangefuncExperiment),
once we switch over to [go1.23](https://go.dev/doc/go1.23).
- `tm2/pkg/sdk`
- As previously mentioned, two hooks were added on the BaseApp to
support injecting application code right before starting a transaction
and then right after ending it; allowing us to inject the code relating
to the Gno.land store while maintaining the modules decoupled
- Other
- `gnovm/pkg/gnolang/machine.go` has a one-line fix for a bug printing
the machine, whereby it would panic if len(blocks) == 0.

## Open questions / notes

- TransactionalStore should be a different implementation altogether;
but decoupling the logic which is used within the stores without doing a
massive copy-and-paste of the entire defaultStore implementation is
non-trivial. See [this
comment](#2319 (comment)),
and [this PR](#2655) for a draft
proposed store refactor, which would render the store more modular and
testable.
- There is an alternative implementation, which in micro-benchmarks
would be somewhat faster, in place of the `txLog`; it's still in
`gnolang/internal/txlog/txlog_test.go` where it also has benchmarks. See
[1347c5f](1347c5f)
for the solution which uses `bufferedTxMap`, without using the
`txlog.Map` interface. The main problem with this approach is that it
does not support stacking bufferedTxMaps, thus there is a different
method to be used in preprocess - `preprocessFork()`.

contribs/gnodev/pkg/dev/node.go

@@ -469,7 +469,9 @@ func (n *Node) rebuildNode(ctx context.Context, genesis gnoland.GnoGenesisState)
 
  // Setup node config
  nodeConfig := newNodeConfig(n.config.TMConfig, n.config.ChainID, genesis)
- nodeConfig.GenesisTxHandler = n.genesisTxHandler
+ 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.
@@ -512,7 +514,7 @@ func (n *Node) rebuildNode(ctx context.Context, genesis gnoland.GnoGenesisState)
  return nil
 }
 
-func (n *Node) genesisTxHandler(ctx sdk.Context, tx std.Tx, res sdk.Result) {
+func (n *Node) genesisTxResultHandler(ctx sdk.Context, tx std.Tx, res sdk.Result) {
  if !res.IsErr() {
  return
  }

gno.land/cmd/gnoland/testdata/issue_2283_cacheTypes.txtar

@@ -101,4 +101,3 @@ import (
 func Call(s string) {
  base64.StdEncoding.DecodeString("hey")
 }
-

gno.land/cmd/gnoland/testdata/restart_nonval.txtar

@@ -0,0 +1,5 @@
+# This txtar tests for starting up a non-validator node; then also restarting it.
+loadpkg gno.land/p/demo/avl
+
+gnoland start -non-validator
+gnoland restart

gno.land/pkg/gnoland/app.go

@@ -1,10 +1,12 @@
+// Package gnoland contains the bootstrapping code to launch a gno.land node.
 package gnoland
 
 import (
  "fmt"
  "log/slog"
  "path/filepath"
  "strconv"
+ "time"
 
  "github.com/gnolang/gno/gno.land/pkg/sdk/vm"
  "github.com/gnolang/gno/gnovm/pkg/gnoenv"
@@ -25,48 +27,46 @@ import (
  // Only goleveldb is supported for now.
  _ "github.com/gnolang/gno/tm2/pkg/db/_tags"
  _ "github.com/gnolang/gno/tm2/pkg/db/goleveldb"
- "github.com/gnolang/gno/tm2/pkg/db/memdb"
 )
 
+// AppOptions contains the options to create the gno.land ABCI application.
 type AppOptions struct {
- DB dbm.DB
- // `gnoRootDir` should point to the local location of the gno repository.
- // It serves as the gno equivalent of GOROOT.
- GnoRootDir string
- GenesisTxHandler GenesisTxHandler
- Logger *slog.Logger
- EventSwitch events.EventSwitch
- MaxCycles int64
- // Whether to cache the result of loading the standard libraries.
- // This is useful if you have to start many nodes, like in testing.
- // This disables loading existing packages; so it should only be used
- // on a fresh database.
- CacheStdlibLoad bool
+ DB dbm.DB // required
+ Logger *slog.Logger // required
+ EventSwitch events.EventSwitch // required
+ MaxCycles int64 // hard limit for cycles in GnoVM
+ InitChainerConfig // options related to InitChainer
 }
 
-func NewAppOptions() *AppOptions {
+// DefaultAppOptions provides a "ready" default [AppOptions] for use with
+// [NewAppWithOptions], using the provided db.
+func TestAppOptions(db dbm.DB) *AppOptions {
  return &AppOptions{
- GenesisTxHandler: PanicOnFailingTxHandler,
- Logger: log.NewNoopLogger(),
- DB: memdb.NewMemDB(),
- GnoRootDir: gnoenv.RootDir(),
- EventSwitch: events.NilEventSwitch(),
+ DB: db,
+ Logger: log.NewNoopLogger(),
+ EventSwitch: events.NewEventSwitch(),
+ InitChainerConfig: InitChainerConfig{
+ GenesisTxResultHandler: PanicOnFailingTxResultHandler,
+ StdlibDir: filepath.Join(gnoenv.RootDir(), "gnovm", "stdlibs"),
+ CacheStdlibLoad: true,
+ },
  }
 }
 
-func (c *AppOptions) validate() error {
- if c.Logger == nil {
- return fmt.Errorf("no logger provided")
- }
-
- if c.DB == nil {
+func (c AppOptions) validate() error {
+ // Required fields
+ switch {
+ case c.DB == nil:
  return fmt.Errorf("no db provided")
+ case c.Logger == nil:
+ return fmt.Errorf("no logger provided")
+ case c.EventSwitch == nil:
+ return fmt.Errorf("no event switch provided")
  }
-
  return nil
 }
 
-// NewAppWithOptions creates the GnoLand application with specified options
+// NewAppWithOptions creates the gno.land application with specified options.
 func NewAppWithOptions(cfg *AppOptions) (abci.Application, error) {
  if err := cfg.validate(); err != nil {
  return nil, err
@@ -88,13 +88,13 @@ func NewAppWithOptions(cfg *AppOptions) (abci.Application, error) {
  // Construct keepers.
  acctKpr := auth.NewAccountKeeper(mainKey, ProtoGnoAccount)
  bankKpr := bank.NewBankKeeper(acctKpr)
-
- // XXX: Embed this ?
- stdlibsDir := filepath.Join(cfg.GnoRootDir, "gnovm", "stdlibs")
- vmk := vm.NewVMKeeper(baseKey, mainKey, acctKpr, bankKpr, stdlibsDir, cfg.MaxCycles)
+ vmk := vm.NewVMKeeper(baseKey, mainKey, acctKpr, bankKpr, cfg.MaxCycles)
 
  // Set InitChainer
- baseApp.SetInitChainer(InitChainer(baseApp, acctKpr, bankKpr, cfg.GenesisTxHandler))
+ icc := cfg.InitChainerConfig
+ icc.baseApp = baseApp
+ icc.acctKpr, icc.bankKpr, icc.vmKpr = acctKpr, bankKpr, vmk
+ baseApp.SetInitChainer(icc.InitChainer)
 
  // Set AnteHandler
  authOptions := auth.AnteOptions{
@@ -108,14 +108,28 @@ func NewAppWithOptions(cfg *AppOptions) (abci.Application, error) {
  newCtx sdk.Context, res sdk.Result, abort bool,
  ) {
  // Override auth params.
- ctx = ctx.WithValue(
- auth.AuthParamsContextKey{}, auth.DefaultParams())
+ ctx = ctx.
+ WithValue(auth.AuthParamsContextKey{}, auth.DefaultParams())
  // Continue on with default auth ante handler.
  newCtx, res, abort = authAnteHandler(ctx, tx, simulate)
  return
  },
  )
 
+ // Set begin and end transaction hooks.
+ // These are used to create gno transaction stores and commit them when finishing
+ // the tx - in other words, data from a failing transaction won't be persisted
+ // to the gno store caches.
+ baseApp.SetBeginTxHook(func(ctx sdk.Context) sdk.Context {
+ // Create Gno transaction store.
+ return vmk.MakeGnoTransactionStore(ctx)
+ })
+ baseApp.SetEndTxHook(func(ctx sdk.Context, result sdk.Result) {
+ if result.IsOK() {
+ vmk.CommitGnoTransactionStore(ctx)
+ }
+ })
+
  // Set up the event collector
  c := newCollector[validatorUpdate](
  cfg.EventSwitch, // global event switch filled by the node
@@ -143,13 +157,13 @@ func NewAppWithOptions(cfg *AppOptions) (abci.Application, error) {
 
  // Initialize the VMKeeper.
  ms := baseApp.GetCacheMultiStore()
- vmk.Initialize(cfg.Logger, ms, cfg.CacheStdlibLoad)
+ vmk.Initialize(cfg.Logger, ms)
  ms.MultiWrite() // XXX why was't this needed?
 
  return baseApp, nil
 }
 
-// NewApp creates the GnoLand application.
+// NewApp creates the gno.land application.
 func NewApp(
  dataRootDir string,
  skipFailingGenesisTxs bool,
@@ -158,9 +172,16 @@ func NewApp(
 ) (abci.Application, error) {
  var err error
 
- cfg := NewAppOptions()
+ cfg := &AppOptions{
+ Logger: logger,
+ EventSwitch: evsw,
+ InitChainerConfig: InitChainerConfig{
+ GenesisTxResultHandler: PanicOnFailingTxResultHandler,
+ StdlibDir: filepath.Join(gnoenv.RootDir(), "gnovm", "stdlibs"),
+ },
+ }
  if skipFailingGenesisTxs {
- cfg.GenesisTxHandler = NoopGenesisTxHandler
+ cfg.GenesisTxResultHandler = NoopGenesisTxResultHandler
  }
 
  // Get main DB.
@@ -169,74 +190,135 @@ func NewApp(
  return nil, fmt.Errorf("error initializing database %q using path %q: %w", dbm.GoLevelDBBackend, dataRootDir, err)
  }
 
- cfg.Logger = logger
- cfg.EventSwitch = evsw
-
  return NewAppWithOptions(cfg)
 }
 
-type GenesisTxHandler func(ctx sdk.Context, tx std.Tx, res sdk.Result)
+// GenesisTxResultHandler is called in the InitChainer after a genesis
+// transaction is executed.
+type GenesisTxResultHandler func(ctx sdk.Context, tx std.Tx, res sdk.Result)
 
-func NoopGenesisTxHandler(_ sdk.Context, _ std.Tx, _ sdk.Result) {}
+// NoopGenesisTxResultHandler is a no-op GenesisTxResultHandler.
+func NoopGenesisTxResultHandler(_ sdk.Context, _ std.Tx, _ sdk.Result) {}
 
-func PanicOnFailingTxHandler(_ sdk.Context, _ std.Tx, res sdk.Result) {
+// PanicOnFailingTxResultHandler handles genesis transactions by panicking if
+// res.IsErr() returns true.
+func PanicOnFailingTxResultHandler(_ sdk.Context, _ std.Tx, res sdk.Result) {
  if res.IsErr() {
  panic(res.Log)
  }
 }
 
-// InitChainer returns a function that can initialize the chain with genesis.
-func InitChainer(
- baseApp *sdk.BaseApp,
- acctKpr auth.AccountKeeperI,
- bankKpr bank.BankKeeperI,
- resHandler GenesisTxHandler,
-) func(sdk.Context, abci.RequestInitChain) abci.ResponseInitChain {
- return func(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
- txResponses := []abci.ResponseDeliverTx{}
-
- if req.AppState != nil {
- // Get genesis state
- genState := req.AppState.(GnoGenesisState)
-
- // Parse and set genesis state balances
- for _, bal := range genState.Balances {
- acc := acctKpr.NewAccountWithAddress(ctx, bal.Address)
- acctKpr.SetAccount(ctx, acc)
- err := bankKpr.SetCoins(ctx, bal.Address, bal.Amount)
- if err != nil {
- panic(err)
- }
- }
-
- // Run genesis txs
- for _, tx := range genState.Txs {
- res := baseApp.Deliver(tx)
- if res.IsErr() {
- ctx.Logger().Error(
- "Unable to deliver genesis tx",
- "log", res.Log,
- "error", res.Error,
- "gas-used", res.GasUsed,
- )
- }
-
- txResponses = append(txResponses, abci.ResponseDeliverTx{
- ResponseBase: res.ResponseBase,
- GasWanted: res.GasWanted,
- GasUsed: res.GasUsed,
- })
-
- resHandler(ctx, tx, res)
- }
- }
+// InitChainerConfig keeps the configuration for the InitChainer.
+// [NewAppWithOptions] will set [InitChainerConfig.InitChainer] as its InitChainer
+// function.
+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
 
- // Done!
+ // These fields are passed directly by NewAppWithOptions, and should not be
+ // configurable by end-users.
+ baseApp *sdk.BaseApp
+ vmKpr vm.VMKeeperI
+ acctKpr auth.AccountKeeperI
+ bankKpr bank.BankKeeperI
+}
+
+// InitChainer is the function that can be used as a [sdk.InitChainer].
+func (cfg InitChainerConfig) InitChainer(ctx sdk.Context, req abci.RequestInitChain) abci.ResponseInitChain {
+ 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)
+ if err != nil {
  return abci.ResponseInitChain{
- Validators: req.Validators,
- TxResponses: txResponses,
+ ResponseBase: abci.ResponseBase{
+ Error: abci.StringError(err.Error()),
+ },
  }
  }
+
+ ctx.Logger().Debug("InitChainer: genesis transactions loaded",
+ "elapsed", time.Since(start))
+
+ // Done!
+ return abci.ResponseInitChain{
+ Validators: req.Validators,
+ TxResponses: txResponses,
+ }
+}
+
+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 {
+ return nil, fmt.Errorf("invalid AppState of type %T", appState)
+ }
+
+ // Parse and set genesis state balances
+ for _, bal := range state.Balances {
+ acc := cfg.acctKpr.NewAccountWithAddress(ctx, bal.Address)
+ cfg.acctKpr.SetAccount(ctx, acc)
+ err := cfg.bankKpr.SetCoins(ctx, bal.Address, bal.Amount)
+ if err != nil {
+ panic(err)
+ }
+ }
+
+ txResponses := make([]abci.ResponseDeliverTx, 0, len(state.Txs))
+ // Run genesis txs
+ for _, tx := range state.Txs {
+ res := cfg.baseApp.Deliver(tx)
+ if res.IsErr() {
+ ctx.Logger().Error(
+ "Unable to deliver genesis tx",
+ "log", res.Log,
+ "error", res.Error,
+ "gas-used", res.GasUsed,
+ )
+ }
+
+ txResponses = append(txResponses, abci.ResponseDeliverTx{
+ ResponseBase: res.ResponseBase,
+ GasWanted: res.GasWanted,
+ GasUsed: res.GasUsed,
+ })
+
+ cfg.GenesisTxResultHandler(ctx, tx, res)
+ }
+ return txResponses, nil
 }
 
 // endBlockerApp is the app abstraction required by any EndBlocker