chore(evmengine): refactor evmmsgs

client/x/evmengine/keeper/evmmsgs.go

@@ -1,10 +1,7 @@
 package keeper
 
 import (
- "bytes"
  "context"
- "slices"
- "sort"
 
  "github.com/ethereum/go-ethereum"
  "github.com/ethereum/go-ethereum/common"
@@ -31,41 +28,18 @@ func (k *Keeper) evmEvents(ctx context.Context, blockHash common.Hash) ([]*types
  return nil, errors.Wrap(err, "filter logs")
  }
 
- ll := make([]*types.EVMEvent, 0, len(logs))
+ events = make([]*types.EVMEvent, 0, len(logs))
  for _, l := range logs {
- topics := make([][]byte, 0, len(l.Topics))
- for _, t := range l.Topics {
- topics = append(topics, t.Bytes())
+ evmEvent, err := types.EthLogToEVMEvent(l)
+ if err != nil {
+ return nil, errors.Wrap(err, "convert log")
  }
- ll = append(ll, &types.EVMEvent{
- Address: l.Address.Bytes(),
- Topics: topics,
- Data: l.Data,
- })
- }
 
- for _, log := range ll {
- if err := log.Verify(); err != nil {
- return nil, errors.Wrap(err, "verify log")
- }
+ events = append(events, evmEvent)
  }
- events = append(events, ll...)
 
- // Sort by Address > Topics > Data
  // This avoids dependency on runtime ordering.
- sort.Slice(events, func(i, j int) bool {
- if cmp := bytes.Compare(events[i].Address, events[j].Address); cmp != 0 {
- return cmp < 0
- }
-
- topicI := slices.Concat(events[i].Topics...)
- topicJ := slices.Concat(events[j].Topics...)
- if cmp := bytes.Compare(topicI, topicJ); cmp != 0 {
- return cmp < 0
- }
-
- return bytes.Compare(events[i].Data, events[j].Data) < 0
- })
+ types.SortEVMEvents(events)
 
  return events, nil
 }

client/x/evmengine/types/tx.go

@@ -1,6 +1,10 @@
 package types
 
 import (
+ "bytes"
+ "slices"
+ "sort"
+
  "github.com/ethereum/go-ethereum/common"
  ethtypes "github.com/ethereum/go-ethereum/core/types"
 
@@ -47,3 +51,73 @@ func (l *EVMEvent) Verify() error {
 
  return nil
 }
+
+// EthLogToEVMEvent converts an Ethereum Log to an EVMEvent.
+func EthLogToEVMEvent(ethLog ethtypes.Log) (*EVMEvent, error) {
+ topics := make([][]byte, 0, len(ethLog.Topics))
+ for _, t := range ethLog.Topics {
+ topics = append(topics, t.Bytes())
+ }
+
+ evmEvent := &EVMEvent{
+ Address: ethLog.Address.Bytes(),
+ Topics: topics,
+ Data: ethLog.Data,
+ }
+ if err := evmEvent.Verify(); err != nil {
+ return nil, errors.Wrap(err, "verify log")
+ }
+
+ return evmEvent, nil
+}
+
+// SortEVMEvents sorts EVM events by Address > Topics > Data.
+func SortEVMEvents(events []*EVMEvent) {
+ sort.Slice(events, func(i, j int) bool {
+ if cmp := bytes.Compare(events[i].Address, events[j].Address); cmp != 0 {
+ return cmp < 0
+ }
+
+ topicI := slices.Concat(events[i].Topics...)
+ topicJ := slices.Concat(events[j].Topics...)
+ if cmp := bytes.Compare(topicI, topicJ); cmp != 0 {
+ return cmp < 0
+ }
+
+ return bytes.Compare(events[i].Data, events[j].Data) < 0
+ })
+}
+
+// IsSortedEVMEvents check if the events are sorted by ascending order of address, topics, and data.
+func IsSortedEVMEvents(events []*EVMEvent) bool {
+ for i := 1; i < len(events); i++ {
+ // Compare addresses first
+ addressComparison := bytes.Compare(events[i-1].Address, events[i].Address)
+ if addressComparison > 0 {
+ // it is not sorted by ascending order of address
+ return false
+ }
+
+ if addressComparison == 0 {
+ // If addresses are equal, compare by topics
+ previousTopic := slices.Concat(events[i-1].Topics...)
+ currentTopic := slices.Concat(events[i].Topics...)
+ topicComparison := bytes.Compare(previousTopic, currentTopic)
+
+ if topicComparison > 0 {
+ // it is not sorted by ascending order of topics
+ return false
+ }
+
+ if topicComparison == 0 {
+ // If topics are also equal, compare by data
+ if bytes.Compare(events[i-1].Data, events[i].Data) > 0 {
+ // it is not sorted by ascending order of data
+ return false
+ }
+ }
+ }
+ }
+
+ return true
+}