feat(gnovm, tm2): implement event emission with std.Emit

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

@@ -13,7 +13,8 @@ gnokey maketx call -pkgpath gno.land/r/foobar/bar -func Render -gas-fee 1000000u
 stdout '("hello from foo" string)'
 stdout 'OK!'
 stdout 'GAS WANTED: 2000000'
-stdout 'GAS USED:   [0-9]+'
+stdout 'GAS USED: \d+'
+stdout 'EVENTS: null'
 
 -- bar.gno --
 package bar

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

@@ -0,0 +1,60 @@
+# start a new node
+gnoland start
+
+gnokey maketx addpkg -pkgdir $WORK -pkgpath gno.land/r/demo/ee -gas-fee 1000000ugnot -gas-wanted 2500000 -broadcast -chainid=tendermint_test test1
+stdout OK!
+stdout 'GAS WANTED: 2500000'
+stdout 'GAS USED: [0-9]+'
+stdout 'EVENTS: null'
+
+gnokey maketx call -pkgpath gno.land/r/demo/ee -func Sender -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
+stdout OK!
+stdout 'GAS WANTED: 2000000'
+stdout 'GAS USED: [0-9]+'
+stdout 'EVENTS: \[?.*sender.*SubSender.*receiver.*SubReceiver.*\]'
+
+gnokey maketx call -pkgpath gno.land/r/demo/ee -func Receiver -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
+stdout OK!
+stdout 'GAS WANTED: 2000000'
+stdout 'GAS USED: [0-9]+'
+stdout 'EVENTS: \[?.*(R|r)eceiver.*\]'
+
+-- ee.gno --
+package ee
+
+import (
+	"std"
+)
+
+const (
+	EventSender = "sender"
+	EventReceiver = "receiver"
+)
+
+func Sender(){
+    SubSender()
+    SubReceiver()
+}
+
+func SubSender() {
+    std.Emit(
+        EventSender,
+		"key1", "value1",
+		"key2", "value2",
+		"key3", "value3",
+    )  
+}
+
+func SubReceiver() {
+    std.Emit(
+        EventReceiver,
+        "bar", "baz",
+    )
+}
+
+func Receiver() {
+    std.Emit(
+        EventReceiver,
+        "foo", "bar",
+    )
+}

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

@@ -186,6 +186,7 @@
 		OrigSendSpent: new(std.Coins),
 		OrigPkgAddr:   pkgAddr.Bech32(),
 		Banker:        NewSDKBanker(vm, ctx),
+		EventLogger:   ctx.EventLogger(),
 	}
 	// Parse and run the files, construct *PV.
 	m2 := gno.NewMachineWithOptions(
@@ -263,6 +264,7 @@
 		OrigSendSpent: new(std.Coins),
 		OrigPkgAddr:   pkgAddr.Bech32(),
 		Banker:        NewSDKBanker(vm, ctx),
+		EventLogger:   ctx.EventLogger(),
 	}
 	// Construct machine and evaluate.
 	m := gno.NewMachineWithOptions(
@@ -334,6 +336,7 @@
 		OrigSendSpent: new(std.Coins),
 		OrigPkgAddr:   pkgAddr.Bech32(),
 		Banker:        NewSDKBanker(vm, ctx),
+		EventLogger:   ctx.EventLogger(),
 	}
 	// Parse and run the files, construct *PV.
 	buf := new(bytes.Buffer)
@@ -463,6 +466,7 @@
 		// OrigSendSpent: nil,
 		OrigPkgAddr: pkgAddr.Bech32(),
 		Banker:      NewSDKBanker(vm, ctx), // safe as long as ctx is a fork to be discarded.
+		EventLogger: ctx.EventLogger(),
 	}
 	m := gno.NewMachineWithOptions(
 		gno.MachineOptions{
@@ -523,6 +527,7 @@
 		// OrigSendSpent: nil,
 		OrigPkgAddr: pkgAddr.Bech32(),
 		Banker:      NewSDKBanker(vm, ctx), // safe as long as ctx is a fork to be discarded.
+		EventLogger: ctx.EventLogger(),
 	}
 	m := gno.NewMachineWithOptions(
 		gno.MachineOptions{

gnovm/stdlibs/std/context.go

@@ -17,4 +17,5 @@ type ExecContext struct {
 	OrigSend      std.Coins
 	OrigSendSpent *std.Coins // mutable
 	Banker        BankerInterface
+	EventLogger   *sdk.EventLogger
 }

gnovm/stdlibs/std/emit_event.gno

@@ -0,0 +1,14 @@
+package std
+
+// Emit is a function that constructs a GnoEvent with a specified type and attributes.
+// It then forwards this event to the event logger. Each emitted event carries metadata
+// such as the timestamp of emission, the event type, and the provided attributes.
+//
+// The function takes arguments in pairs. The first element of each pair is considered
+// the attribute key, and the second element is the corresponding value.
+//
+// The event is dispatched to the EventLogger, which resides in the tm2/pkg/sdk/events.go file.
+//
+// For more details about the GnoEvent data structure, refer to its definition in the emit_event.go file.
+func Emit(typ string, attrs ...string) { emit(typ, attrs) }
+func emit(typ string, attrs []string)

gnovm/stdlibs/std/emit_event.go

@@ -0,0 +1,77 @@
+package std
+
+// ref: https://github.com/gnolang/gno/pull/853
+
+import (
+	"encoding/json"
+	"errors"
+
+	gno "github.com/gnolang/gno/gnovm/pkg/gnolang"
+	abci "github.com/gnolang/gno/tm2/pkg/bft/abci/types"
+)
+
+func X_emit(m *gno.Machine, typ string, attrs []string) {
+	eventAttrs, err := attrKeysAndValues(attrs)
+	if err != nil {
+		m.Panic(typedString(err.Error()))
+	}
+
+	pkgPath := CurrentRealmPath(m)
+	fnIdent := getPrevFunctionNameFromTarget(m, "Emit")
+	timestamp := getTimestamp(m)
+
+	evtstr := NewGnoEventString(typ, pkgPath, fnIdent, timestamp, eventAttrs...)
+	ctx := m.Context.(ExecContext)
+	ctx.EventLogger.EmitEvent(evtstr)
+}
+
+func attrKeysAndValues(attrs []string) ([]gnoEventAttribute, error) {
+	attrLen := len(attrs)
+	if attrLen%2 != 0 {
+		return nil, errors.New("odd number of attributes. cannot create key-value pairs")
+	}
+	eventAttrs := make([]gnoEventAttribute, attrLen/2)
+	for i := 0; i < attrLen-1; i += 2 {
+		eventAttrs[i/2] = gnoEventAttribute{
+			Key:   attrs[i],
+			Value: attrs[i+1],
+		}
+	}
+	return eventAttrs, nil
+}
+
+type temp gnoEvent
+
+func NewGnoEventString(eventType, pkgPath, ident string, timestamp int64, attrs ...gnoEventAttribute) abci.EventString {
+	evt := newGnoEvent(eventType, pkgPath, ident, timestamp, attrs...)
+
+	jsonRes, err := json.Marshal(map[string]temp{evt.Type: temp(*evt)})
+	if err != nil {
+		panic(err)
+	}
+
+	return abci.EventString(jsonRes)
+}
+
+type gnoEvent struct {
+	Type       string              `json:"-"`
+	PkgPath    string              `json:"pkg_path"`
+	Identifier string              `json:"identifier"`
+	Timestamp  int64               `json:"timestamp"`
+	Attributes []gnoEventAttribute `json:"attributes"`
+}
+
+func newGnoEvent(eventType string, pkgPath string, ident string, timestamp int64, attrs ...gnoEventAttribute) *gnoEvent {
+	return &gnoEvent{
+		Type:       eventType,
+		PkgPath:    pkgPath,
+		Identifier: ident,
+		Attributes: attrs,
+		Timestamp:  timestamp,
+	}
+}
+
+type gnoEventAttribute struct {
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}

gnovm/stdlibs/std/native.go

@@ -32,6 +32,20 @@ func GetHeight(m *gno.Machine) int64 {
 	return m.Context.(ExecContext).Height
 }
 
+func getTimestamp(m *gno.Machine) int64 {
+	return m.Context.(ExecContext).Timestamp
+}
+
+// getPrevFunctionNameFromTarget returns the last called function name (identifier) from the call stack.
+func getPrevFunctionNameFromTarget(m *gno.Machine, targetFunc string) string {
+	for i := 0; i < len(m.Frames); i++ {
+		if m.Frames[i].Func.Name == gno.Name(targetFunc) && i > 0 {
+			return string(m.Frames[i-1].Func.Name)
+		}
+	}
+	return ""
+}
+
 func X_origSend(m *gno.Machine) (denoms []string, amounts []int64) {
 	os := m.Context.(ExecContext).OrigSend
 	return ExpandCoins(os)

gnovm/stdlibs/std/package.go

@@ -0,0 +1,19 @@
+package std
+
+import (
+	"github.com/gnolang/gno/tm2/pkg/amino"
+	abci "github.com/gnolang/gno/tm2/pkg/bft/abci/types"
+)
+
+var Package = amino.RegisterPackage(amino.NewPackage(
+	"github.com/gnolang/gno/gnovm/stdlibs/std",
+	"tm",
+	amino.GetCallersDirname(),
+).
+	WithDependencies(
+		abci.Package,
+	).
+	WithTypes(
+		gnoEventAttribute{},
+		gnoEvent{},
+	))

gnovm/tests/file.go

@@ -17,6 +17,7 @@ import (
 	"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/sdk"
 	"github.com/gnolang/gno/tm2/pkg/std"
 	"github.com/pmezard/go-difflib/difflib"
 )
@@ -50,6 +51,7 @@ func testMachineCustom(store gno.Store, pkgPath string, stdout io.Writer, maxAll
 		OrigSend:      send,
 		OrigSendSpent: new(std.Coins),
 		Banker:        banker,
+		EventLogger:   sdk.NewEventLogger(),
 	}
 	m := gno.NewMachineWithOptions(gno.MachineOptions{
 		PkgPath:       "", // set later.

gnovm/tests/files/zrealm_natbind0.gno

@@ -141,7 +141,7 @@ func main() {
 //                 "Closure": {
 //                     "@type": "/gno.RefValue",
 //                     "Escaped": true,
-//                     "ObjectID": "a7f5397443359ea76c50be82c77f1f893a060925:6"
+//                     "ObjectID": "a7f5397443359ea76c50be82c77f1f893a060925:7"
 //                 },
 //                 "FileName": "native.gno",
 //                 "IsMethod": false,

tm2/pkg/bft/abci/types/types.go

@@ -1,6 +1,7 @@
 package abci
 
 import (
+	"encoding/json"
 	"time"
 
 	"github.com/gnolang/gno/tm2/pkg/crypto"
@@ -116,6 +117,14 @@ func (r ResponseBase) IsErr() bool {
 	return r.Error != nil
 }
 
+func (r ResponseBase) EncodeEvent() []byte {
+	res, err := json.Marshal(r.Events)
+	if err != nil {
+		return nil
+	}
+	return res
+}
+
 // nondeterministic
 type ResponseException struct {
 	ResponseBase

tm2/pkg/crypto/keys/client/maketx.go

@@ -180,7 +180,8 @@ func ExecSignAndBroadcast(
 	io.Println(string(bres.DeliverTx.Data))
 	io.Println("OK!")
 	io.Println("GAS WANTED:", bres.DeliverTx.GasWanted)
-	io.Println("GAS USED:  ", bres.DeliverTx.GasUsed)
+	io.Println("GAS USED:", bres.DeliverTx.GasUsed)
+	io.Println("EVENTS:", string(bres.DeliverTx.EncodeEvent()))
 
 	return nil
 }

tm2/pkg/sdk/baseapp.go

@@ -653,6 +653,7 @@ func (app *BaseApp) runMsgs(ctx Context, msgs []Msg, mode RunTxMode) (result Res
 		// each result.
 		data = append(data, msgResult.Data...)
 		events = append(events, msgResult.Events...)
+		events = append(events, ctx.EventLogger().Events()...)
 		// TODO append msgevent from ctx. XXX XXX
 
 		// stop execution and return on first failed message

tm2/pkg/sdk/sdk.proto

@@ -12,4 +12,4 @@ message Result {
 	abci.ResponseBase response_base = 1 [json_name = "ResponseBase"];
 	sint64 gas_wanted = 2 [json_name = "GasWanted"];
 	sint64 gas_used = 3 [json_name = "GasUsed"];
-}
+}