ConvertProof unit tests

common/utils.go

@@ -0,0 +1,11 @@
+package common
+
+import (
+	"encoding/hex"
+	"strings"
+)
+
+// DecodeHex decodes hex encoded string to raw byte slice
+func DecodeHex(input string) ([]byte, error) {
+	return hex.DecodeString(strings.TrimPrefix(input, "0x"))
+}

etherman/etherman.go

@@ -21,7 +21,8 @@ import (
 )
 
 const (
-	HashLength = 32
+	HashLength  = 32
+	ProofLength = 24
 )
 
 type Etherman struct {

etherman/helpers_test.go

@@ -0,0 +1,37 @@
+package etherman
+
+import (
+	"bytes"
+	"crypto/rand"
+	"encoding/hex"
+)
+
+func generateRandomHexString(length int) (string, error) {
+	numBytes := length / 2
+	randomBytes := make([]byte, numBytes)
+
+	if _, err := rand.Read(randomBytes); err != nil {
+		return "", err
+	}
+
+	return hex.EncodeToString(randomBytes), nil
+}
+
+func generateProof() (string, error) {
+	var buf bytes.Buffer
+	buf.WriteString("0x")
+
+	for i := 0; i < 2*ProofLength; i++ {
+		hash, err := generateRandomHexString(HashLength)
+		if err != nil {
+			return "", err
+		}
+
+		_, err = buf.WriteString(hash)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return buf.String(), nil
+}

etherman/proof.go

@@ -1,23 +1,53 @@
 package etherman
 
 import (
+	"bytes"
 	"fmt"
 	"strings"
 
 	"github.com/0xPolygon/cdk-validium-node/encoding"
 )
 
-type Proof [24][HashLength]byte
+type Proof [ProofLength][HashLength]byte
+
+func (p Proof) Equals(other Proof) bool {
+	for i := 0; i < len(p); i++ {
+		if !bytes.Equal(p[i][:], other[i][:]) {
+			return false
+		}
+	}
+	return true
+}
+
+func BytesToProof(data []byte) (Proof, error) {
+	// Check if the length of the input data is compatible with the Proof type
+	expectedLength := ProofLength * HashLength
+	if len(data) != expectedLength {
+		return Proof{}, fmt.Errorf("invalid byte slice length. Expected length: %d, Actual length: %d", expectedLength, len(data))
+	}
+
+	// Create a Proof type and copy the data into it
+	var proof Proof
+	for i := 0; i < ProofLength; i++ {
+		copy(proof[i][:], data[i*HashLength:(i+1)*HashLength])
+	}
+
+	return proof, nil
+}
 
 func ConvertProof(p string) (Proof, error) {
-	const expectedLength = 24*HashLength*2 + 2
+	const (
+		expectedLength = ProofLength*HashLength*2 + 2
+		rawHashLength  = 2 * HashLength // 1 byte gets substituted with 2 hex digits (1 hex digit = nibble = 4 bits)
+	)
+
 	if len(p) != expectedLength {
 		return Proof{}, fmt.Errorf("invalid proof length. Expected length: %d, Actual length %d", expectedLength, len(p))
 	}
 	p = strings.TrimPrefix(p, "0x")
 	proof := Proof{}
-	for i := 0; i < 24; i++ {
-		data := p[i*64 : (i+1)*64]
+	for i := 0; i < ProofLength; i++ {
+		data := p[i*rawHashLength : (i+1)*rawHashLength]
 		p, err := encoding.DecodeBytes(&data)
 		if err != nil {
 			return Proof{}, fmt.Errorf("failed to decode proof, err: %w", err)

etherman/proof_test.go

@@ -0,0 +1,53 @@
+package etherman
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/0xPolygon/beethoven/common"
+)
+
+func TestConvertProof(t *testing.T) {
+	validInputProof, err := generateProof()
+	require.NoError(t, err)
+
+	validRawProof, err := common.DecodeHex(validInputProof)
+	require.NoError(t, err)
+
+	validProof, err := BytesToProof(validRawProof)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name        string
+		input       string
+		expected    Proof
+		expectedErr string
+	}{
+		{
+			name:        "valid proof",
+			input:       validInputProof,
+			expected:    validProof,
+			expectedErr: "",
+		},
+		{
+			name:        "invalid proof length",
+			input:       "0x1234",
+			expectedErr: fmt.Sprintf("invalid proof length. Expected length: %d, Actual length %d", ProofLength*HashLength*2+2, 6),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := ConvertProof(tt.input)
+
+			if tt.expectedErr != "" {
+				require.ErrorContains(t, err, tt.expectedErr)
+			} else {
+				require.NoError(t, err)
+				require.True(t, result.Equals(tt.expected), "expected: %v, actual: %v", tt.expected, result)
+			}
+		})
+	}
+}