feat: add std.PrevRealm

examples/gno.land/p/demo/tests/subtests/subtests.gno

@@ -0,0 +1,17 @@
+package subtests
+
+import (
+	"std"
+)
+
+func CurrentRealmPath() string {
+	return std.CurrentRealmPath()
+}
+
+func GetPrevRealm() std.Realm {
+	return std.PrevRealm()
+}
+
+func Exec(fn func()) {
+	fn()
+}

examples/gno.land/p/demo/tests/tests.gno

@@ -3,7 +3,9 @@ package tests
 import (
 	"std"
 
+	psubtests "gno.land/p/demo/tests/subtests"
 	"gno.land/r/demo/tests"
+	rtests "gno.land/r/demo/tests"
 )
 
 // IncCounter demonstrates that it's possible to call a realm function from
@@ -51,3 +53,20 @@ func ModifyTestRealmObject2b() {
 func ModifyTestRealmObject2c() {
 	SomeValue3.Field = "modified"
 }
+
+func GetPrevRealm() std.Realm {
+	return std.PrevRealm()
+}
+
+func GetPSubtestsPrevRealm() std.Realm {
+	return psubtests.GetPrevRealm()
+}
+
+func GetRTestsGetPrevRealm() std.Realm {
+	return rtests.GetPrevRealm()
+}
+
+// Warning: unsafe pattern.
+func Exec(fn func()) {
+	fn()
+}

examples/gno.land/r/demo/tests/subtests/subtests.gno

@@ -0,0 +1,17 @@
+package subtests
+
+import (
+	"std"
+)
+
+func CurrentRealmPath() string {
+	return std.CurrentRealmPath()
+}
+
+func GetPrevRealm() std.Realm {
+	return std.PrevRealm()
+}
+
+func Exec(fn func()) {
+	fn()
+}

examples/gno.land/r/demo/tests/tests.gno

@@ -1,6 +1,10 @@
 package tests
 
-import "std"
+import (
+	"std"
+
+	"gno.land/r/demo/tests/subtests"
+)
 
 var counter int
 
@@ -69,3 +73,15 @@ func ModTestNodes() {
 func PrintTestNodes() {
 	println(gTestNode2.Child.Name)
 }
+
+func GetPrevRealm() std.Realm {
+	return std.PrevRealm()
+}
+
+func GetPSubtestsPrevRealm() std.Realm {
+	return subtests.GetPrevRealm()
+}
+
+func Exec(fn func()) {
+	fn()
+}

gnovm/pkg/gnolang/frame.go

@@ -1,6 +1,8 @@
 package gnolang
 
-import "fmt"
+import (
+	"fmt"
+)
 
 //----------------------------------------
 // (runtime) Frame

gnovm/stdlibs/frame.go

@@ -0,0 +1,8 @@
+package stdlibs
+
+import "github.com/gnolang/gno/tm2/pkg/crypto"
+
+type Realm struct {
+	Addr    crypto.Bech32Address
+	PkgPath string
+}

gnovm/stdlibs/std/frame.gno

@@ -0,0 +1,10 @@
+package std
+
+type Realm struct {
+	Addr    Address
+	PkgPath string
+}
+
+func (r Realm) IsUser() bool {
+	return r.PkgPath == ""
+}

gnovm/stdlibs/stdlibs.go

@@ -17,6 +17,7 @@ func InjectNativeMappings(store gno.Store) {
 	store.AddGo2GnoMapping(reflect.TypeOf(crypto.Bech32Address("")), "std", "Address")
 	store.AddGo2GnoMapping(reflect.TypeOf(std.Coins{}), "std", "Coins")
 	store.AddGo2GnoMapping(reflect.TypeOf(std.Coin{}), "std", "Coin")
+	store.AddGo2GnoMapping(reflect.TypeOf(Realm{}), "std", "Realm")
 }
 
 func InjectPackage(store gno.Store, pn *gno.PackageNode) {
@@ -286,6 +287,59 @@ func InjectPackage(store gno.Store, pn *gno.PackageNode) {
 				m.PushValue(res0)
 			},
 		)
+		pn.DefineNative("PrevRealm",
+			gno.Flds( // params
+			),
+			gno.Flds( // results
+				"", "Realm",
+			),
+			func(m *gno.Machine) {
+				var (
+					ctx = m.Context.(ExecContext)
+					// Default lastCaller is OrigCaller, the signer of the tx
+					lastCaller  = ctx.OrigCaller
+					lastPkgPath = ""
+				)
+
+				for i := m.NumFrames() - 1; i > 0; i-- {
+					fr := m.Frames[i]
+					if fr.LastPackage == nil || !fr.LastPackage.IsRealm() {
+						// Ignore non-realm frame
+						continue
+					}
+					pkgPath := fr.LastPackage.PkgPath
+					// The first realm we encounter will be the one calling
+					// this function; to get the calling realm determine the first frame
+					// where fr.LastPackage changes.
+					if lastPkgPath != "" && lastPkgPath != pkgPath {
+						lastCaller = fr.LastPackage.GetPkgAddr().Bech32()
+						lastPkgPath = pkgPath
+						break
+					}
+
+					lastPkgPath = pkgPath
+				}
+
+				// Empty the pkgPath if we return a user
+				if ctx.OrigCaller == lastCaller {
+					lastPkgPath = ""
+				}
+
+				// Return the result
+				res0 := gno.Go2GnoValue(
+					m.Alloc,
+					m.Store,
+					reflect.ValueOf(Realm{
+						lastCaller,
+						lastPkgPath,
+					}),
+				)
+
+				realmT := store.GetType(gno.DeclaredTypeID("std", "Realm"))
+				res0.T = realmT
+				m.PushValue(res0)
+			},
+		)
 		pn.DefineNative("GetOrigPkgAddr",
 			gno.Flds( // params
 			),

gnovm/stdlibs/stdshim/frame.gno

@@ -0,0 +1,6 @@
+package std
+
+type Realm struct {
+	Addr    Address
+	PkgPath string
+}

gnovm/stdlibs/stdshim/stdshim.gno

@@ -36,6 +36,14 @@ func GetOrigSend() Coins {
 	return Coins{}
 }
 
+func PrevRealm() Realm {
+	panic(shimWarn)
+	return Realm{
+		Addr:    Address(""),
+		PkgPath: "",
+	}
+}
+
 func GetOrigCaller() Address {
 	panic(shimWarn)
 	return Address("")

gnovm/tests/file.go

@@ -13,13 +13,12 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/pmezard/go-difflib/difflib"
-
 	gno "github.com/gnolang/gno/gnovm/pkg/gnolang"
 	"github.com/gnolang/gno/gnovm/stdlibs"
 	"github.com/gnolang/gno/tm2/pkg/crypto"
 	osm "github.com/gnolang/gno/tm2/pkg/os"
 	"github.com/gnolang/gno/tm2/pkg/std"
+	"github.com/pmezard/go-difflib/difflib"
 )
 
 type loggerFunc func(args ...interface{})

gnovm/tests/files/zrealm_crossrealm11.gno

@@ -0,0 +1,149 @@
+// PKGPATH: gno.land/r/crossrealm_test
+package crossrealm_test
+
+import (
+	"std"
+	"strings"
+
+	ptests "gno.land/p/demo/tests"
+	"gno.land/p/demo/ufmt"
+	rtests "gno.land/r/demo/tests"
+	testfoo "gno.land/r/demo/tests_foo"
+)
+
+func getPrevRealm() std.Realm {
+	return std.PrevRealm()
+}
+
+func Exec(fn func()) {
+	fn()
+}
+
+func main() {
+	// Create a map of the potential callers, this will give more understandable
+	// output than the bech32 addresses.
+	callersByAddr := make(map[std.Address]string)
+	for _, caller := range []string{
+		"user1.gno", "gno.land/r/crossrealm_test", "gno.land/r/demo/tests",
+	} {
+		addr := std.DerivePkgAddr(caller)
+		callersByAddr[addr] = caller
+	}
+
+	assertRealm := func(r std.Realm) {
+		pkgPath := callersByAddr[r.Addr]
+		if r.IsUser() && pkgPath != "user1.gno" {
+			panic(ufmt.Sprintf("ERROR: expected: 'user1.gno', got:'%s'", pkgPath))
+		} else if !r.IsUser() && pkgPath != r.PkgPath {
+			panic(ufmt.Sprintf("ERROR: expected: '%s', got: '%s'", pkgPath, r.PkgPath))
+		}
+	}
+
+	tests := []struct {
+		callStackAdd string
+		callerFn     func() std.Realm
+	}{
+		{
+			callStackAdd: "",
+			callerFn:     std.PrevRealm,
+		},
+		{
+			callStackAdd: " -> r/crossrealm_test.getPrevRealm",
+			callerFn:     getPrevRealm,
+		},
+		{
+			callStackAdd: " -> p/demo/tests",
+			callerFn:     ptests.GetPrevRealm,
+		},
+		{
+			callStackAdd: " -> p/demo/tests -> p/demo/tests/subtests",
+			callerFn:     ptests.GetPSubtestsPrevRealm,
+		},
+		{
+			callStackAdd: " -> r/demo/tests",
+			callerFn:     rtests.GetPrevRealm,
+		},
+		{
+			callStackAdd: " -> r/demo/tests -> r/demo/tests/subtests",
+			callerFn:     rtests.GetPSubtestsPrevRealm,
+		},
+		{
+			callStackAdd: " -> p/demo/tests -> r/demo/tests",
+			callerFn:     ptests.GetRTestsGetPrevRealm,
+		},
+	}
+
+	println("---") // needed to have space prefixes
+	printColumns("STACK", "std.PrevRealm")
+	printColumns("-----", "------------------")
+
+	baseCallStack := "user1.gno -> r/crossrealm_test.main"
+	for i, tt := range tests {
+		printColumns(baseCallStack+tt.callStackAdd, callersByAddr[tt.callerFn().Addr])
+		Exec(func() {
+			r := tt.callerFn()
+			assertRealm(r)
+			printColumns(baseCallStack+" -> r/crossrealm_test.Exec"+tt.callStackAdd, callersByAddr[r.Addr])
+		})
+		rtests.Exec(func() {
+			r := tt.callerFn()
+			assertRealm(r)
+			printColumns(baseCallStack+" -> r/demo/tests.Exec"+tt.callStackAdd, callersByAddr[tt.callerFn().Addr])
+		})
+		ptests.Exec(func() {
+			r := tt.callerFn()
+			assertRealm(r)
+			printColumns(baseCallStack+" -> p/demo/tests.Exec"+tt.callStackAdd, callersByAddr[tt.callerFn().Addr])
+		})
+	}
+}
+
+func printColumns(left, right string) {
+	const w = 105
+
+	output := ""
+	padding := w - len(left)
+
+	// strings.Repeat is not always available when using various imports modes.
+	for i := 0; i < padding; i++ {
+		output += " "
+	}
+
+	output += left
+	output += " = "
+	output += right
+	println(output)
+}
+
+// Output:
+// ---
+//                                                                                                     STACK = std.PrevRealm
+//                                                                                                     ----- = ------------------
+//                                                                       user1.gno -> r/crossrealm_test.main = user1.gno
+//                                             user1.gno -> r/crossrealm_test.main -> r/crossrealm_test.Exec = user1.gno
+//                                                  user1.gno -> r/crossrealm_test.main -> r/demo/tests.Exec = gno.land/r/demo/tests
+//                                                  user1.gno -> r/crossrealm_test.main -> p/demo/tests.Exec = user1.gno
+//                                     user1.gno -> r/crossrealm_test.main -> r/crossrealm_test.getPrevRealm = user1.gno
+//           user1.gno -> r/crossrealm_test.main -> r/crossrealm_test.Exec -> r/crossrealm_test.getPrevRealm = user1.gno
+//                user1.gno -> r/crossrealm_test.main -> r/demo/tests.Exec -> r/crossrealm_test.getPrevRealm = gno.land/r/demo/tests
+//                user1.gno -> r/crossrealm_test.main -> p/demo/tests.Exec -> r/crossrealm_test.getPrevRealm = user1.gno
+//                                                       user1.gno -> r/crossrealm_test.main -> p/demo/tests = user1.gno
+//                             user1.gno -> r/crossrealm_test.main -> r/crossrealm_test.Exec -> p/demo/tests = user1.gno
+//                                  user1.gno -> r/crossrealm_test.main -> r/demo/tests.Exec -> p/demo/tests = gno.land/r/demo/tests
+//                                  user1.gno -> r/crossrealm_test.main -> p/demo/tests.Exec -> p/demo/tests = user1.gno
+//                              user1.gno -> r/crossrealm_test.main -> p/demo/tests -> p/demo/tests/subtests = user1.gno
+//    user1.gno -> r/crossrealm_test.main -> r/crossrealm_test.Exec -> p/demo/tests -> p/demo/tests/subtests = user1.gno
+//         user1.gno -> r/crossrealm_test.main -> r/demo/tests.Exec -> p/demo/tests -> p/demo/tests/subtests = gno.land/r/demo/tests
+//         user1.gno -> r/crossrealm_test.main -> p/demo/tests.Exec -> p/demo/tests -> p/demo/tests/subtests = user1.gno
+//                                                       user1.gno -> r/crossrealm_test.main -> r/demo/tests = gno.land/r/crossrealm_test
+//                             user1.gno -> r/crossrealm_test.main -> r/crossrealm_test.Exec -> r/demo/tests = gno.land/r/crossrealm_test
+//                                  user1.gno -> r/crossrealm_test.main -> r/demo/tests.Exec -> r/demo/tests = gno.land/r/crossrealm_test
+//                                  user1.gno -> r/crossrealm_test.main -> p/demo/tests.Exec -> r/demo/tests = gno.land/r/crossrealm_test
+//                              user1.gno -> r/crossrealm_test.main -> r/demo/tests -> r/demo/tests/subtests = gno.land/r/demo/tests
+//    user1.gno -> r/crossrealm_test.main -> r/crossrealm_test.Exec -> r/demo/tests -> r/demo/tests/subtests = gno.land/r/demo/tests
+//         user1.gno -> r/crossrealm_test.main -> r/demo/tests.Exec -> r/demo/tests -> r/demo/tests/subtests = gno.land/r/demo/tests
+//         user1.gno -> r/crossrealm_test.main -> p/demo/tests.Exec -> r/demo/tests -> r/demo/tests/subtests = gno.land/r/demo/tests
+//                                       user1.gno -> r/crossrealm_test.main -> p/demo/tests -> r/demo/tests = gno.land/r/crossrealm_test
+//             user1.gno -> r/crossrealm_test.main -> r/crossrealm_test.Exec -> p/demo/tests -> r/demo/tests = gno.land/r/crossrealm_test
+//                  user1.gno -> r/crossrealm_test.main -> r/demo/tests.Exec -> p/demo/tests -> r/demo/tests = gno.land/r/crossrealm_test
+//                  user1.gno -> r/crossrealm_test.main -> p/demo/tests.Exec -> p/demo/tests -> r/demo/tests = gno.land/r/crossrealm_test