feat: small improvements for #1702

.gitignore

@@ -30,3 +30,7 @@ pbbindings.go
 # Test coverage leftovers
 cover.out
 coverage.out
+
+*.swp
+*.swo
+*.bak

gno.land/pkg/gnoland/app.go

@@ -120,7 +120,9 @@
 	}
 
 	// Initialize the VMKeeper.
-	vmKpr.Initialize(baseApp.GetCacheMultiStore())
+	ms := baseApp.GetCacheMultiStore()
+	vmKpr.Initialize(ms)
+	ms.MultiWrite() // XXX why was't this needed?
 
 	return baseApp, nil
 }

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

@@ -16,7 +16,7 @@ func (vm *VMKeeper) initBuiltinPackagesAndTypes(store gno.Store) {
 	// NOTE: native functions/methods added here must be quick operations,
 	// or account for gas before operation.
 	// TODO: define criteria for inclusion, and solve gas calculations.
-	getPackage := func(pkgPath string, newStore gno.Store) (pn *gno.PackageNode, pv *gno.PackageValue) {
+	getPackage := func(pkgPath string, store gno.Store) (pn *gno.PackageNode, pv *gno.PackageValue) {
 		// otherwise, built-in package value.
 		// first, load from filepath.
 		stdlibPath := filepath.Join(vm.stdlibsDir, pkgPath)
@@ -34,10 +34,11 @@ func (vm *VMKeeper) initBuiltinPackagesAndTypes(store gno.Store) {
 			PkgPath: "gno.land/r/stdlibs/" + pkgPath,
 			// PkgPath: pkgPath,
 			Output: os.Stdout,
-			Store:  newStore,
+			Store:  store,
 		})
 		defer m2.Release()
-		return m2.RunMemPackage(memPkg, true)
+		pn, pv = m2.RunMemPackage(memPkg, true)
+		return
 	}
 	store.SetPackageGetter(getPackage)
 	store.SetNativeStore(stdlibs.NativeStore)

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

@@ -157,7 +157,6 @@ func (vm *VMKeeper) AddPackage(ctx sdk.Context, msg MsgAddPackage) (err error) {
 	if pv := gnostore.GetPackage(pkgPath, false); pv != nil {
 		return ErrInvalidPkgPath("package already exists: " + pkgPath)
 	}
-
 	if gno.ReGnoRunPath.MatchString(pkgPath) {
 		return ErrInvalidPkgPath("reserved package name: " + pkgPath)
 	}

gnovm/pkg/gnolang/debugger_test.go

@@ -196,7 +196,8 @@ func TestRemoteDebug(t *testing.T) {
 func TestRemoteError(t *testing.T) {
 	_, err := evalTest(":xxx", "", debugTarget)
 	t.Log("err:", err)
-	if !strings.Contains(err, "tcp/xxx: unknown port") {
+	if !strings.Contains(err, "tcp/xxx: unknown port") &&
+		!strings.Contains(err, "tcp/xxx: nodename nor servname provided, or not known") {
 		t.Error(err)
 	}
 }

gnovm/pkg/gnolang/go2gno.go

@@ -478,6 +478,7 @@ func Go2Gno(fs *token.FileSet, gon ast.Node) (n Node) {
 
 //----------------------------------------
 // type checking (using go/types)
+// XXX move to gotypecheck.go.
 
 // MemPackageGetter implements the GetMemPackage() method. It is a subset of
 // [Store], separated for ease of testing.
@@ -539,6 +540,7 @@ func (g *gnoImporter) ImportFrom(path, _ string, _ types.ImportMode) (*types.Pac
 	}
 	mpkg := g.getter.GetMemPackage(path)
 	if mpkg == nil {
+		// fmt.Println("gnoImporter.ImportFrom/was nil", path)
 		err := importNotFoundError(path)
 		g.cache[path] = gnoImporterResult{err: err}
 		return nil, err

gnovm/pkg/gnolang/store.go

@@ -9,16 +9,21 @@
 	"strings"
 
 	"github.com/gnolang/gno/tm2/pkg/amino"
+	"github.com/gnolang/gno/tm2/pkg/colors"
 	"github.com/gnolang/gno/tm2/pkg/std"
 	"github.com/gnolang/gno/tm2/pkg/store"
+	"github.com/gnolang/gno/tm2/pkg/store/types"
+	"github.com/gnolang/gno/tm2/pkg/store/utils"
+	stringz "github.com/gnolang/gno/tm2/pkg/strings"
 )
 
 // PackageGetter specifies how the store may retrieve packages which are not
 // already in its cache. PackageGetter should return nil when the requested
 // package does not exist. store should be used to run the machine, or otherwise
 // call any methods which may call store.GetPackage; avoid using any "global"
 // store as the one passed to the PackageGetter may be a fork of that (ie.
-// the original is not meant to be written to).
+// the original is not meant to be written to). Loading dependencies may
+// cause writes to happen to the store, such as MemPackages to iavlstore.
 type PackageGetter func(pkgPath string, store Store) (*PackageNode, *PackageValue)
 
 // inject natives into a new or loaded package (value and node)
@@ -68,6 +73,8 @@
 	LogSwitchRealm(rlmpath string) // to mark change of realm boundaries
 	ClearCache()
 	Print()
+	Write()
+	Flush()
 }
 
 // Used to keep track of in-mem objects during tx.
@@ -86,7 +93,7 @@
 
 	// transient
 	opslog  []StoreOp // for debugging and testing.
-	current []string
+	current []string  // for detecting import cycles.
 }
 
 func NewStore(alloc *Allocator, baseStore, iavlStore store.Store) *defaultStore {
@@ -115,6 +122,7 @@
 
 // Gets package from cache, or loads it from baseStore, or gets it from package getter.
 func (ds *defaultStore) GetPackage(pkgPath string, isImport bool) *PackageValue {
+	// helper to detect circular imports
 	if isImport {
 		if slices.Contains(ds.current, pkgPath) {
 			panic(fmt.Sprintf("import cycle detected: %q (through %v)", pkgPath, ds.current))
@@ -613,6 +621,7 @@
 	ds.alloc.Reset()
 	ds.cacheObjects = make(map[ObjectID]Object) // new cache.
 	ds.opslog = nil                             // new ops log.
+	//ds.current = nil
 	ds.SetCachePackage(Uverse())
 }
 
@@ -672,8 +681,16 @@
 	return nil
 }
 
+// Writes one level of cache to store.
+func (ds *defaultStore) Write() {
+	ds.baseStore.(types.Writer).Write()
+	ds.iavlStore.(types.Writer).Write()
+}
+
+// Flush cached writes to disk.
 func (ds *defaultStore) Flush() {
-	// XXX
+	ds.baseStore.(types.Flusher).Flush()
+	ds.iavlStore.(types.Flusher).Flush()
 }
 
 // ----------------------------------------
@@ -755,22 +772,25 @@
 
 // for debugging
 func (ds *defaultStore) Print() {
-	fmt.Println("//----------------------------------------")
-	fmt.Println("defaultStore:baseStore...")
-	store.Print(ds.baseStore)
-	fmt.Println("//----------------------------------------")
-	fmt.Println("defaultStore:iavlStore...")
-	store.Print(ds.iavlStore)
-	fmt.Println("//----------------------------------------")
-	fmt.Println("defaultStore:cacheTypes...")
+	fmt.Println(colors.Yellow("//----------------------------------------"))
+	fmt.Println(colors.Green("defaultStore:baseStore..."))
+	utils.Print(ds.baseStore)
+	fmt.Println(colors.Yellow("//----------------------------------------"))
+	fmt.Println(colors.Green("defaultStore:iavlStore..."))
+	utils.Print(ds.iavlStore)
+	fmt.Println(colors.Yellow("//----------------------------------------"))
+	fmt.Println(colors.Green("defaultStore:cacheTypes..."))
 	for tid, typ := range ds.cacheTypes {
-		fmt.Printf("- %v: %v\n", tid, typ)
+		fmt.Printf("- %v: %v\n", tid,
+			stringz.TrimN(fmt.Sprintf("%v", typ), 50))
 	}
-	fmt.Println("//----------------------------------------")
-	fmt.Println("defaultStore:cacheNodes...")
+	fmt.Println(colors.Yellow("//----------------------------------------"))
+	fmt.Println(colors.Green("defaultStore:cacheNodes..."))
 	for loc, bn := range ds.cacheNodes {
-		fmt.Printf("- %v: %v\n", loc, bn)
+		fmt.Printf("- %v: %v\n", loc,
+			stringz.TrimN(fmt.Sprintf("%v", bn), 50))
 	}
+	fmt.Println(colors.Red("//----------------------------------------"))
 }
 
 // ----------------------------------------

gnovm/tests/imports.go

@@ -61,8 +61,8 @@ const (
 )
 
 // NOTE: this isn't safe, should only be used for testing.
-func TestStore(rootDir, filesPath string, stdin io.Reader, stdout, stderr io.Writer, mode importMode) (store gno.Store) {
-	getPackage := func(pkgPath string, newStore gno.Store) (pn *gno.PackageNode, pv *gno.PackageValue) {
+func TestStore(rootDir, filesPath string, stdin io.Reader, stdout, stderr io.Writer, mode importMode) (resStore gno.Store) {
+	getPackage := func(pkgPath string, store gno.Store) (pn *gno.PackageNode, pv *gno.PackageValue) {
 		if pkgPath == "" {
 			panic(fmt.Sprintf("invalid zero package path in testStore().pkgGetter"))
 		}
@@ -83,7 +83,7 @@ func TestStore(rootDir, filesPath string, stdin io.Reader, stdout, stderr io.Wri
 				m2 := gno.NewMachineWithOptions(gno.MachineOptions{
 					PkgPath: "test",
 					Output:  stdout,
-					Store:   newStore,
+					Store:   store,
 					Context: ctx,
 				})
 				// pkg := gno.NewPackageNode(gno.Name(memPkg.Name), memPkg.Path, nil)
@@ -96,7 +96,7 @@ func TestStore(rootDir, filesPath string, stdin io.Reader, stdout, stderr io.Wri
 		// if stdlibs package is preferred , try to load it first.
 		if mode == ImportModeStdlibsOnly ||
 			mode == ImportModeStdlibsPreferred {
-			pn, pv = loadStdlib(rootDir, pkgPath, newStore, stdout)
+			pn, pv = loadStdlib(rootDir, pkgPath, store, stdout)
 			if pn != nil {
 				return
 			}
@@ -375,7 +375,7 @@ func TestStore(rootDir, filesPath string, stdin io.Reader, stdout, stderr io.Wri
 
 		// if native package is preferred, try to load stdlibs/* as backup.
 		if mode == ImportModeNativePreferred {
-			pn, pv = loadStdlib(rootDir, pkgPath, newStore, stdout)
+			pn, pv = loadStdlib(rootDir, pkgPath, store, stdout)
 			if pn != nil {
 				return
 			}
@@ -394,23 +394,23 @@ func TestStore(rootDir, filesPath string, stdin io.Reader, stdout, stderr io.Wri
 			m2 := gno.NewMachineWithOptions(gno.MachineOptions{
 				PkgPath: "test",
 				Output:  stdout,
-				Store:   newStore,
+				Store:   store,
 				Context: ctx,
 			})
 			pn, pv = m2.RunMemPackage(memPkg, true)
 			return
 		}
 		return nil, nil
 	}
-	// NOTE: store is also used in closure above.
 	db := memdb.NewMemDB()
 	baseStore := dbadapter.StoreConstructor(db, stypes.StoreOptions{})
 	iavlStore := iavl.StoreConstructor(db, stypes.StoreOptions{})
-	store = gno.NewStore(nil, baseStore, iavlStore)
-	store.SetPackageGetter(getPackage)
-	store.SetNativeStore(teststdlibs.NativeStore)
-	store.SetPackageInjector(testPackageInjector)
-	store.SetStrictGo2GnoMapping(false)
+	// make a new store
+	resStore = gno.NewStore(nil, baseStore, iavlStore)
+	resStore.SetPackageGetter(getPackage)
+	resStore.SetNativeStore(teststdlibs.NativeStore)
+	resStore.SetPackageInjector(testPackageInjector)
+	resStore.SetStrictGo2GnoMapping(false)
 	return
 }
 

tm2/pkg/db/goleveldb/go_level_db.go

@@ -6,8 +6,10 @@ import (
 	"fmt"
 	"path/filepath"
 
+	"github.com/gnolang/gno/tm2/pkg/colors"
 	"github.com/gnolang/gno/tm2/pkg/db"
 	"github.com/gnolang/gno/tm2/pkg/db/internal"
+	"github.com/gnolang/gno/tm2/pkg/strings"
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/errors"
 	"github.com/syndtr/goleveldb/leveldb/iterator"
@@ -115,9 +117,9 @@ func (db *GoLevelDB) Print() {
 
 	itr := db.db.NewIterator(nil, nil)
 	for itr.Next() {
-		key := itr.Key()
-		value := itr.Value()
-		fmt.Printf("[%X]:\t[%X]\n", key, value)
+		key := colors.ColoredBytes([]byte(strings.TrimN(string(itr.Key()), 50)), colors.Blue, colors.Green)
+		value := colors.ColoredBytes([]byte(strings.TrimN(string(itr.Value()), 50)), colors.Blue, colors.Green)
+		fmt.Printf("%v:\t%v\n", key, value)
 	}
 }
 

tm2/pkg/db/memdb/mem_db.go

@@ -5,6 +5,7 @@
 	"sort"
 	"sync"
 
+	"github.com/gnolang/gno/tm2/pkg/colors"
 	dbm "github.com/gnolang/gno/tm2/pkg/db"
 	"github.com/gnolang/gno/tm2/pkg/db/internal"
 	"github.com/gnolang/gno/tm2/pkg/strings"
@@ -128,16 +129,8 @@
 
 	for key, value := range db.db {
 		var keystr, valstr string
-		if strings.IsASCIIText(key) {
-			keystr = key
-		} else {
-			keystr = fmt.Sprintf("0x%X", []byte(key))
-		}
-		if strings.IsASCIIText(string(value)) {
-			valstr = string(value)
-		} else {
-			valstr = fmt.Sprintf("0x%X", value)
-		}
+		keystr = colors.ColoredBytes([]byte(strings.TrimN(string(key), 50)), colors.Green, colors.Blue)
+		valstr = colors.ColoredBytes([]byte(strings.TrimN(string(value), 50)), colors.Green, colors.Blue)
 		fmt.Printf("%s:\t%s\n", keystr, valstr)
 	}
 }

tm2/pkg/db/prefix_db.go

@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"fmt"
 	"sync"
+
+	"github.com/gnolang/gno/tm2/pkg/colors"
 )
 
 // IteratePrefix is a convenience function for iterating over a key domain
@@ -188,15 +190,10 @@ func (pdb *PrefixDB) Close() {
 
 // Implements DB.
 func (pdb *PrefixDB) Print() {
-	fmt.Printf("prefix: %X\n", pdb.prefix)
-
-	itr := pdb.Iterator(nil, nil)
-	defer itr.Close()
-	for ; itr.Valid(); itr.Next() {
-		key := itr.Key()
-		value := itr.Value()
-		fmt.Printf("[%X]:\t[%X]\n", key, value)
-	}
+	fmt.Println(colors.Blue("prefix ---------------------"))
+	fmt.Printf("prefix: %v\n", colors.ColoredBytes(pdb.prefix, colors.Green, colors.Blue))
+	pdb.db.Print()
+	fmt.Println(colors.Blue("prefix --------------------- end"))
 }
 
 // Implements DB.

tm2/pkg/sdk/auth/ante.go

@@ -157,7 +157,6 @@ func NewAnteHandler(ak AccountKeeper, bank BankKeeperI, sigGasConsumer Signature
 				if err != nil {
 					return newCtx, res, true
 				}
-
 				signerAccs[i], res = processSig(newCtx, sacc, stdSigs[i], signBytes, simulate, params, sigGasConsumer)
 				if !res.IsOK() {
 					return newCtx, res, true

tm2/pkg/sdk/baseapp.go

@@ -223,6 +223,10 @@ func (app *BaseApp) GetCacheMultiStore() store.MultiStore {
 	return app.cms.MultiCacheWrap()
 }
 
+func (app *BaseApp) GetCMS() store.CommitMultiStore {
+	return app.cms
+}
+
 // Router returns the router of the BaseApp.
 func (app *BaseApp) Router() Router {
 	if app.sealed {
@@ -615,6 +619,9 @@ func (app *BaseApp) getContextForTx(mode RunTxMode, txBytes []byte) (ctx Context
 		WithVoteInfos(app.voteInfos).
 		WithConsensusParams(app.consensusParams)
 
+	// NOTE: This is especially required to simulate transactions because
+	// otherwise baseapp writes the antehandler mods (sequence and balance)
+	// to the underlying store for deliver and checktx.
 	if mode == RunTxModeSimulate {
 		ctx, _ = ctx.CacheContext()
 	}