x/evm/types/utils.go (1)

73-73: LGTM! Consider standardizing error handling patterns

The change to errors.New is appropriate for static error messages. However, for consistency, consider using a custom error type or error wrapping for all error cases in this file.

Consider creating custom error types for common errors:

var (
    ErrNilTransaction = errors.New("invalid tx: nil")
    ErrInvalidTxType = func(t any) error { return fmt.Errorf("invalid tx type: %T", t) }
    ErrTxNotFound = func(hash string) error { return fmt.Errorf("eth tx not found: %s", hash) }
)

x/evm/types/msg.go (1)

230-230: LGTM! Consider adding error documentation

The change to errors.New is appropriate. The error handling throughout this file consistently uses error wrapping where context is needed.

Consider adding error documentation for common errors:

// Common errors returned by MsgEthereumTx methods
var (
    // ErrSenderNotDefined is returned when attempting to sign a transaction without a defined sender
    ErrSenderNotDefined = errors.New("sender address not defined for message")
)

x/evm/core/tracers/js/goja.go (1)

86-86: LGTM! Consider adding error documentation.

The change from fmt.Errorf to errors.New is appropriate since no string formatting is needed. This follows Go best practices for error creation.

Consider documenting the scenarios that can trigger this error by adding a comment above the function explaining what constitutes an "invalid buffer type". This would help developers understand and handle the error case better.

+// fromBuf converts a JavaScript value to a byte slice. It accepts:
+// - Uint8Array: converted to []byte directly
+// - String: converted from hex if allowString is true
+// - Array: converted to []byte if elements are valid
+// Returns "invalid buffer type" error for other types.
 func fromBuf(vm *goja.Runtime, bufType goja.Value, buf goja.Value, allowString bool) ([]byte, error) {

Configuration used: CodeRabbit UI
Review profile: CHILL

x/evm/core/vm/stack_test.go (2)

24-55: Consider using table-driven tests and cleanup

While the test cases are comprehensive, consider these improvements:

1. Convert to table-driven tests for better maintainability
2. Add cleanup to reset stackPool after the test

Example refactor:

 func TestNewStack(t *testing.T) {
-    stackPool = sync.Pool{
-        New: func() interface{} {
-            return &Stack{}
-        },
-    }
-
-    stack, err := NewStack()
-    if err != nil {
-        t.Errorf("Expected no error, got %v", err)
-    }
-    if stack == nil {
-        t.Errorf("Expected a non-nil Stack, got nil")
-    }
-
-    stackPool = sync.Pool{
-        New: func() interface{} {
-            return "not a Stack"
-        },
-    }
+    originalPool := stackPool
+    defer func() {
+        stackPool = originalPool
+    }()
+
+    tests := []struct {
+        name    string
+        poolNew func() interface{}
+        wantErr string
+    }{
+        {
+            name: "success",
+            poolNew: func() interface{} {
+                return &Stack{}
+            },
+        },
+        {
+            name: "type assertion failure",
+            poolNew: func() interface{} {
+                return "not a Stack"
+            },
+            wantErr: "type assertion failure: cannot get Stack pointer from stackPool",
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            stackPool = sync.Pool{New: tt.poolNew}
+            
+            stack, err := NewStack()
+            if tt.wantErr != "" {
+                if err == nil || err.Error() != tt.wantErr {
+                    t.Errorf("NewStack() error = %v, wantErr %v", err, tt.wantErr)
+                }
+                if stack != nil {
+                    t.Errorf("Expected nil Stack when error, got %v", stack)
+                }
+            } else {
+                if err != nil {
+                    t.Errorf("NewStack() unexpected error = %v", err)
+                }
+                if stack == nil {
+                    t.Errorf("Expected non-nil Stack")
+                }
+            }
+        })
+    }

---

57-88: Consider reducing test duplication

The TestNewReturnStack function is nearly identical to TestNewStack with just type differences. Consider extracting common test logic to reduce duplication.

Example approach using a generic test helper:

+func testPoolCreation[T any](t *testing.T, newFunc func() (*T, error), pool *sync.Pool, validObj T) {
+    originalPool := *pool
+    defer func() {
+        *pool = originalPool
+    }()
+
+    tests := []struct {
+        name    string
+        poolNew func() interface{}
+        wantErr string
+    }{
+        {
+            name: "success",
+            poolNew: func() interface{} {
+                return &validObj
+            },
+        },
+        {
+            name: "type assertion failure",
+            poolNew: func() interface{} {
+                return "not valid"
+            },
+            wantErr: fmt.Sprintf("type assertion failure: cannot get %T pointer from pool", validObj),
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            *pool = sync.Pool{New: tt.poolNew}
+            
+            result, err := newFunc()
+            if tt.wantErr != "" {
+                if err == nil || err.Error() != tt.wantErr {
+                    t.Errorf("error = %v, wantErr %v", err, tt.wantErr)
+                }
+                if result != nil {
+                    t.Errorf("Expected nil result when error, got %v", result)
+                }
+            } else {
+                if err != nil {
+                    t.Errorf("unexpected error = %v", err)
+                }
+                if result == nil {
+                    t.Errorf("Expected non-nil result")
+                }
+            }
+        })
+    }
+}
+
 func TestNewStack(t *testing.T) {
-    // Current implementation
+    testPoolCreation(t, NewStack, &stackPool, Stack{})
 }
 
 func TestNewReturnStack(t *testing.T) {
-    // Current implementation
+    testPoolCreation(t, NewReturnStack, &rStackPool, ReturnStack{})
 }

Configuration used: CodeRabbit UI
Review profile: CHILL

x/evm/core/vm/interpreter.go (1)

260-262: Excellent improvement in error handling robustness

The change from direct error comparison to errors.Is is a significant improvement that:

• Enables detection of wrapped errors containing errStopToken
• Follows Go 1.13+ error handling best practices
• Makes the code more maintainable and future-proof

This change goes beyond the PR's original scope (replacing fmt.Errorf with errors.New) but adds valuable robustness to the error handling.

Consider applying similar errors.Is improvements to other error checks in the codebase for consistency.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

x/evm/core/vm/stack_test.go (2)

24-75: Consider refactoring the helper function for better maintainability.

The runTest function could benefit from some refactoring to improve maintainability and reduce code duplication:

Consider splitting the function into smaller, more focused helpers:

-func runTest(t *testing.T, name string, newFunc func() interface{}, expectErr bool, errMsg string, testFunc interface{}, pool *sync.Pool) {
+// Generic test result checker
+func checkTestResult[T any](t *testing.T, result T, err error, expectErr bool, errMsg string) {
+	if expectErr {
+		if err == nil {
+			t.Errorf("Expected error, got nil")
+		} else if err.Error() != errMsg {
+			t.Errorf("Expected error message %q, got %q", errMsg, err.Error())
+		}
+		if result != nil {
+			t.Errorf("Expected nil result, got %v", result)
+		}
+		return
+	}
+	if err != nil {
+		t.Errorf("Expected no error, got %v", err)
+	}
+	if result == nil {
+		t.Errorf("Expected a non-nil result, got nil")
+	}
+}
+
+func runTest(t *testing.T, name string, newFunc func() interface{}, expectErr bool, errMsg string, testFunc interface{}, pool *sync.Pool) {
     t.Run(name, func(t *testing.T) {
         originalPool := *pool
         defer func() { *pool = originalPool }()
         pool.New = newFunc
 
         switch tf := testFunc.(type) {
         case func() (*Stack, error):
             stack, err := tf()
-            if expectErr {
-                if err == nil {
-                    t.Errorf("Expected error, got nil")
-                } else if err.Error() != errMsg {
-                    t.Errorf("Expected error message %q, got %q", errMsg, err.Error())
-                }
-                if stack != nil {
-                    t.Errorf("Expected nil Stack, got %v", stack)
-                }
-            } else {
-                if err != nil {
-                    t.Errorf("Expected no error, got %v", err)
-                }
-                if stack == nil {
-                    t.Errorf("Expected a non-nil Stack, got nil")
-                }
-            }
+            checkTestResult(t, stack, err, expectErr, errMsg)
         case func() (*ReturnStack, error):
             rStack, err := tf()
-            if expectErr {
-                if err == nil {
-                    t.Errorf("Expected error, got nil")
-                } else if err.Error() != errMsg {
-                    t.Errorf("Expected error message %q, got %q", errMsg, err.Error())
-                }
-                if rStack != nil {
-                    t.Errorf("Expected nil ReturnStack, got %v", rStack)
-                }
-            } else {
-                if err != nil {
-                    t.Errorf("Expected no error, got %v", err)
-                }
-                if rStack == nil {
-                    t.Errorf("Expected a non-nil ReturnStack, got nil")
-                }
-            }
+            checkTestResult(t, rStack, err, expectErr, errMsg)
         default:
             t.Fatalf("Unexpected test function signature")
         }
     })
 }

This refactoring:

1. Extracts the common test result checking logic into a generic helper
2. Reduces code duplication
3. Makes the code more maintainable
4. Improves readability

---

102-125: Consider reducing duplication between test functions.

While the implementation is correct, there's an opportunity to reduce duplication between TestNewStack and TestNewReturnStack.

Consider creating a generic test function:

+type stackTestCase struct {
+    name      string
+    newFunc   func() interface{}
+    expectErr bool
+    errMsg    string
+}
+
+func runStackTest(t *testing.T, tests []stackTestCase, newStackFunc interface{}, pool *sync.Pool) {
+    for _, tt := range tests {
+        runTest(t, tt.name, tt.newFunc, tt.expectErr, tt.errMsg, newStackFunc, pool)
+    }
+}
+
 func TestNewStack(t *testing.T) {
-    tests := []struct {
-        name      string
-        newFunc   func() interface{}
-        expectErr bool
-        errMsg    string
-    }{
+    tests := []stackTestCase{
         {
             name:      "Valid Stack allocation",
             newFunc:   func() interface{} { return &Stack{} },
             expectErr: false,
         },
         {
             name:      "Invalid Stack allocation",
             newFunc:   func() interface{} { return "not a Stack" },
             expectErr: true,
             errMsg:    "type assertion failure: cannot get Stack pointer from stackPool",
         },
     }
-    for _, tt := range tests {
-        runTest(t, tt.name, tt.newFunc, tt.expectErr, tt.errMsg, NewStack, &stackPool)
-    }
+    runStackTest(t, tests, NewStack, &stackPool)
 }

This would:

1. Reduce code duplication
2. Make it easier to add new stack-related tests
3. Keep the test structure consistent

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro