feat(stylus): decode event into topics and find its signature

Author: Ro6afF

cmd/wazero/wazero.go

@@ -214,6 +214,10 @@ func doRun(args []string, stdOut io.Writer, stdErr logging.Writer) int {
 	flags.StringVar(&stylusTracePath, "stylus", "",
 		"Imports the EVM hook functions and mocks their IO according the result of debug_traceTransaction in the path provided.")
 
+	var stylusSignatureMapPath string
+	flags.StringVar(&stylusSignatureMapPath, "stylus-signature-map", "",
+		"Signature map of the EVM events. Used to decode events.")
+
 	var traceDir string
 	flags.StringVar(&traceDir, "trace-dir", "",
 		"Directory where to save the trace record. If empty - no trace is produced. Default \"\".")
@@ -344,7 +348,7 @@ func doRun(args []string, stdOut io.Writer, stdErr logging.Writer) int {
 
 	var stylusState *stylus.StylusTrace
 	if stylusTracePath != "" {
-		stylusState, err = stylus.Instantiate(ctx, rt, stylusTracePath, traceRecordPtr)
+		stylusState, err = stylus.Instantiate(ctx, rt, stylusTracePath, stylusSignatureMapPath, traceRecordPtr)
 		if err != nil {
 			fmt.Fprintf(stdErr, "error reading stylus trace: %v\n", err)
 			return 1

internal/stylus/stylus.go

@@ -3,24 +3,34 @@ package stylus
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"os"
 
 	"github.com/metacraft-labs/trace_record"
 	"github.com/tetratelabs/wazero"
 )
 
-func Instantiate(ctx context.Context, r wazero.Runtime, stylusTracePath string, record *trace_record.TraceRecord) (*StylusTrace, error) {
+func Instantiate(ctx context.Context, r wazero.Runtime, stylusTracePath string, stylusSignatureMapPath string, record *trace_record.TraceRecord) (*StylusTrace, error) {
+	stylusState := StylusTrace{}
+
 	stylusTraceJson, err := os.ReadFile(stylusTracePath)
 	if err != nil {
 		return nil, err
 	}
 
-	stylusState := StylusTrace{}
-
 	if err := json.Unmarshal(stylusTraceJson, &stylusState.events); err != nil {
 		return nil, err
 	}
 
+	stylusSignatureMapJson, err := os.ReadFile(stylusSignatureMapPath)
+	if err != nil {
+		fmt.Printf("Can't read signature map. Error: %v\n", err)
+	}
+
+	if err := json.Unmarshal(stylusSignatureMapJson, &stylusState.eventSignatureMap); err != nil {
+		fmt.Printf("Can't parse signature map. Error: %v\n", err)
+	}
+
 	moduleBuilder := r.NewHostModuleBuilder("vm_hooks")
 	moduleBuilder = exportSylusFunctions(moduleBuilder, &stylusState, record)
 

internal/stylus/stylus_funcs.go

@@ -376,12 +376,37 @@ func exportEmitLog(mb wazero.HostModuleBuilder, trace *StylusTrace, record *trac
 		func(m api.Module, stack []uint64, event evmEvent) {
 			mem := m.Memory()
 			dataPtr := uint32(stack[0])
-			len := uint32(stack[1])
-			data := readMemoryBytes(mem, dataPtr, len)
+			rawDataLen := uint32(stack[1])
+			numTopics := stack[2]
+
+			rawData := readMemoryBytes(mem, dataPtr, rawDataLen)
 			_ = event
 
-			// TODO: convert this to human readable format
-			record.RegisterRecordEvent(trace_record.EventKindEvmEvent, "emit_log", hexBytes(data))
+			topics := make([][]byte, numTopics)
+			for i := range numTopics {
+				topics[i] = rawData[i*32 : (i*32 + 32)]
+			}
+
+			data := rawData[numTopics*32:]
+
+			content := ""
+
+			if signature, hasSignature := trace.eventSignatureMap[hexBytes(topics[0])]; hasSignature {
+				content += signature
+				// TODO: display topics and data in human-readable way
+			} else {
+				// TODO: discuss if using https://www.4byte.directory/ as fallback for resolving signatures is a good idea
+			}
+
+			for i := range numTopics {
+				content = fmt.Sprintf("%s\nTOPIC[%d] = %s", content, i, hexBytes(topics[i]))
+			}
+
+			if len(data) > 0 {
+				content = fmt.Sprintf("%s\nDATA = %s", content, hexBytes(data))
+			}
+
+			record.RegisterRecordEvent(trace_record.EventKindEvmEvent, "emit_log", content)
 		})
 }
 

internal/stylus/stylus_trace.go

@@ -65,6 +65,8 @@ func (e *evmEvent) UnmarshalJSON(data []byte) error {
 type StylusTrace struct {
 	events  []evmEvent
 	current int
+
+	eventSignatureMap map[string]string
 }
 
 func (st *StylusTrace) nextEvent(event string) (evmEvent, error) {