test: add tests for calculateMevFromBlock, calculateBlockUncleReward, calculateUncleReward & verifyName methods

Author: Monika-Bitfly

backend/pkg/executionlayer/transformer_test.go

@@ -2,6 +2,7 @@ package executionlayer
 
 import (
 	"bytes"
+	"fmt"
 	"math/big"
 	"reflect"
 	"testing"
@@ -1958,3 +1959,221 @@ func TestCalculateTxFee(t *testing.T) {
 		})
 	}
 }
+
+func TestCalculateMevFromBlock(t *testing.T) {
+	tests := []struct {
+		name     string
+		block    *types.Eth1Block
+		expected *big.Int
+	}{
+		{
+			name: "no MEV",
+			block: &types.Eth1Block{
+				Coinbase: []byte("coinbase"),
+				Transactions: []*types.Eth1Transaction{
+					{
+						Itx: []*types.Eth1InternalTransaction{
+							{
+								From:  alice,
+								To:    common.Address{}.Bytes(),
+								Value: big.NewInt(100).Bytes(),
+							},
+						},
+					},
+				},
+			},
+			expected: big.NewInt(0),
+		},
+		{
+			name: "MEV from one transaction",
+			block: &types.Eth1Block{
+				Coinbase: []byte("coinbase"),
+				Transactions: []*types.Eth1Transaction{
+					{
+						Itx: []*types.Eth1InternalTransaction{
+							{
+								From:  alice,
+								To:    []byte("coinbase"),
+								Value: big.NewInt(100).Bytes(),
+							},
+						},
+					},
+				},
+			},
+			expected: big.NewInt(100),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := calculateMevFromBlock(tt.block)
+			if result.Cmp(tt.expected) != 0 {
+				t.Errorf("got %v, want %v", result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestCalculateBlockUncleReward(t *testing.T) {
+	tests := []struct {
+		name     string
+		block    *types.Eth1Block
+		chainID  string
+		expected *big.Int
+	}{
+		{
+			name: "no uncles",
+			block: &types.Eth1Block{
+				Uncles: []*types.Eth1Block{},
+			},
+			chainID:  "1",
+			expected: big.NewInt(0),
+		},
+		{
+			name: "one uncle",
+			block: &types.Eth1Block{
+				Number:     10,
+				Difficulty: big.NewInt(100).Bytes(),
+				Uncles: []*types.Eth1Block{
+					{
+						Number: 1,
+					},
+				},
+			},
+			chainID:  "1",
+			expected: new(big.Int).Div(eth1BlockReward("1", 10, big.NewInt(100).Bytes()), big.NewInt(32)),
+		},
+		{
+			name: "two uncles",
+			block: &types.Eth1Block{
+				Number:     10,
+				Difficulty: big.NewInt(100).Bytes(),
+				Uncles: []*types.Eth1Block{
+					{
+						Number: 1,
+					},
+					{
+						Number: 2,
+					},
+				},
+			},
+			chainID:  "1",
+			expected: new(big.Int).Mul(big.NewInt(2), new(big.Int).Div(eth1BlockReward("1", 10, big.NewInt(100).Bytes()), big.NewInt(32))),
+		},
+		{
+			name: "no uncle rewards",
+			block: &types.Eth1Block{
+				Number:     10,
+				Difficulty: []byte{},
+				Uncles: []*types.Eth1Block{
+					{
+						Number: 1,
+					},
+				},
+			},
+			chainID:  "1",
+			expected: big.NewInt(0),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := calculateBlockUncleReward(tt.block, tt.chainID)
+			if result.Cmp(tt.expected) != 0 {
+				t.Errorf("got %v, want %v", result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestCalculateUncleReward(t *testing.T) {
+	tests := []struct {
+		name     string
+		block    *types.Eth1Block
+		uncle    *types.Eth1Block
+		chainID  string
+		expected *big.Int
+	}{
+		{
+			name: "no uncles",
+			block: &types.Eth1Block{
+				Uncles: []*types.Eth1Block{},
+			},
+			chainID:  "1",
+			expected: big.NewInt(0),
+		},
+		{
+			name: "one uncle",
+			block: &types.Eth1Block{
+				Number:     10,
+				Difficulty: big.NewInt(100).Bytes(),
+			},
+			uncle: &types.Eth1Block{
+				Number: 1,
+			},
+			chainID:  "1",
+			expected: new(big.Int).Div(eth1BlockReward("1", 10, big.NewInt(100).Bytes()), big.NewInt(32)),
+		},
+		{
+			name: "no uncle rewards",
+			block: &types.Eth1Block{
+				Number:     10,
+				Difficulty: []byte{},
+			},
+			uncle: &types.Eth1Block{
+				Number: 1,
+			},
+			chainID:  "1",
+			expected: big.NewInt(0),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := calculateUncleReward(tt.block, tt.uncle, tt.chainID)
+			if result.Cmp(tt.expected) != 0 {
+				t.Errorf("got %v, want %v", result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestVerifyName(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected error
+	}{
+		{
+			name:     "valid name",
+			input:    "test",
+			expected: nil,
+		},
+		{
+			name:     "empty name",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "maximum length name",
+			input:    string(make([]byte, 2048)),
+			expected: nil,
+		},
+		{
+			name:     "name too long",
+			input:    string(make([]byte, 2049)),
+			expected: fmt.Errorf("name too long: %v", string(make([]byte, 2049))),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := verifyName(tt.input)
+			if (result == nil && tt.expected != nil) || (result != nil && tt.expected == nil) {
+				t.Errorf("got %v, want %v", result, tt.expected)
+			} else if result != nil && tt.expected != nil && result.Error() != tt.expected.Error() {
+				t.Errorf("got %v, want %v", result, tt.expected)
+			}
+		})
+	}
+}