feat(keeper): add vm/qpath query

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

@@ -0,0 +1,17 @@
+loadpkg gno.land/r/foobar $WORK
+
+gnoland start
+
+gnokey query vm/qpaths -data "0:1"
+! stdout 'gno.land/r/foobar'
+
+
+gnokey query vm/qpaths -data "0:100"
+stdout 'gno.land/r/foobar'
+
+-- foo.gno --
+package main
+
+func main() {
+ 	println("foo")
+}

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

@@ -1,8 +1,11 @@
 package vm
 
 import (
+	"bytes"
 	"context"
+	"encoding/json"
 	"fmt"
+	"strconv"
 	"strings"
 
 	abci "github.com/gnolang/gno/tm2/pkg/bft/abci/types"
@@ -79,6 +82,7 @@
 	QueryFuncs   = "qfuncs"
 	QueryEval    = "qeval"
 	QueryFile    = "qfile"
+	QueryPaths   = "qpaths"
 )
 
 func (vh vmHandler) Query(ctx sdk.Context, req abci.RequestQuery) abci.ResponseQuery {
@@ -100,6 +104,8 @@
 		res = vh.queryEval(ctx, req)
 	case QueryFile:
 		res = vh.queryFile(ctx, req)
+	case QueryPaths:
+		res = vh.queryPaths(ctx, req)
 	default:
 		return sdk.ABCIResponseQueryFromError(
 			std.ErrUnknownRequest(fmt.Sprintf(
@@ -178,6 +184,51 @@
 	return
 }
 
+// queryPaths retrieves paginated package paths based on request data.
+// The request format is "offset:limit". If not provided, defaults are offset=0 and limit=50.
+func (vh vmHandler) queryPaths(ctx sdk.Context, req abci.RequestQuery) (res abci.ResponseQuery) {
+	var err error
+	var limit, offset int
+
+	data := bytes.TrimSpace(req.Data)
+	before, after, found := strings.Cut(string(data), ":")
+	if !found {
+		res = sdk.ABCIResponseQueryFromError(
+			fmt.Errorf("invalid data format, should be `offset:limit`"),
+		)
+		return
+	}
+
+	if offset, err = strconv.Atoi(before); err != nil {
+		res = sdk.ABCIResponseQueryFromError(
+			fmt.Errorf("unable to parse limit %q: %w", before, err),
+		)
+	} else if limit, err = strconv.Atoi(after); err != nil {
+		res = sdk.ABCIResponseQueryFromError(
+			fmt.Errorf("unable to parse offset %q: %w", after, err),
+		)
+	}
+
+	if res.Error != nil {
+		return
+	}
+
+	paths, err := vh.vm.QueryPackagesPath(ctx, offset, limit)
+	if err != nil {
+		res = sdk.ABCIResponseQueryFromError(err)
+		return
+	}
+
+	res.Data, err = json.Marshal(paths)
+	if err != nil {
+		res = sdk.ABCIResponseQueryFromError(
+			fmt.Errorf("unable to marshal result: %w", err),
+		)
+	}
+
+	return
+}
+
 // queryEval evaluates any expression in readonly mode and returns the results.
 func (vh vmHandler) queryEval(ctx sdk.Context, req abci.RequestQuery) (res abci.ResponseQuery) {
 	pkgPath, expr := parseQueryEvalData(string(req.Data))

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

@@ -634,6 +634,24 @@
 	return res, nil
 }
 
+const MaxPackagesLimit = 100
+
+// QueryPackagesPath returns public facing function signatures.
+func (vm *VMKeeper) QueryPackagesPath(ctx sdk.Context, page, pageSize int) (paths []string, err error) {
+	if page < 0 {
+		return nil, fmt.Errorf("invalid page, cannot be negative")
+	}
+
+	if pageSize > MaxPackagesLimit || pageSize < 0 {
+		return nil, fmt.Errorf("invalid page size, cannot be negative or above %d ", MaxPackagesLimit)
+	}
+
+	store := vm.newGnoTransactionStore(ctx) // throwaway (never committed) // XXX: is that really needed ?
+	offset := page * pageSize
+	paths = store.ListMemPackagePath(uint64(offset), uint64(pageSize))
+	return paths, nil
+}
+
 // QueryFuncs returns public facing function signatures.
 func (vm *VMKeeper) QueryFuncs(ctx sdk.Context, pkgPath string) (fsigs FunctionSignatures, err error) {
 	store := vm.newGnoTransactionStore(ctx) // throwaway (never committed)

gnovm/pkg/gnolang/store.go

@@ -64,6 +64,7 @@
 	AddMemPackage(memPkg *std.MemPackage)
 	GetMemPackage(path string) *std.MemPackage
 	GetMemFile(path string, name string) *std.MemFile
+	ListMemPackagePath(offset, limit uint64) []string
 	IterMemPackage() <-chan *std.MemPackage
 	ClearObjectCache()                                    // run before processing a message
 	SetPackageInjector(PackageInjector)                   // for natives
@@ -704,6 +705,36 @@
 	return memFile
 }
 
+// ListMemPackagePath retrieves a paginated list of package paths.
+func (ds *defaultStore) ListMemPackagePath(offset, limit uint64) []string {
+	ctrkey := []byte(backendPackageIndexCtrKey())
+	ctrbz := ds.baseStore.Get(ctrkey)
+	if ctrbz == nil {
+		return nil
+	}
+
+	ctr, err := strconv.Atoi(string(ctrbz))
+	if err != nil {
+		panic(fmt.Errorf("failed to convert counter to integer: %w", err))
+	}
+
+	paths := make([]string, 0, limit)
+	to := min(uint64(ctr), offset+limit)
+
+	// Fetching and filtering data
+	for from := offset + 1; from <= to; from++ {
+		idxkey := []byte(backendPackageIndexKey(from))
+		path := ds.baseStore.Get(idxkey)
+		if path == nil {
+			panic(fmt.Errorf("missing package index %d", from))
+		}
+
+		paths = append(paths, string(path))
+	}
+
+	return paths
+}
+
 func (ds *defaultStore) IterMemPackage() <-chan *std.MemPackage {
 	ctrkey := []byte(backendPackageIndexCtrKey())
 	ctrbz := ds.baseStore.Get(ctrkey)