Remove v1 code (#84)

- Removed all v1 legacy code and validator app support
- Refactored codebase to follow Go best practices:
  - Added exported constants and sentinel errors
  - Converted tests to table-driven style
  - Improved documentation with GoDoc comments
  - Extracted helper functions for better readability
  
Close #52

Author: abenso

common.go

@@ -18,89 +18,99 @@ package ledger_cosmos_go
 
 import (
 	"encoding/binary"
+	"errors"
 	"fmt"
 )
 
-// VersionInfo contains app version information
+const (
+	// bip32PathLength is the required number of elements in a BIP32/BIP44 path
+	bip32PathLength = 5
+
+	// bip32BytesLength is the byte length of the serialized BIP32 path (5 elements * 4 bytes)
+	bip32BytesLength = 20
+
+	// hardenedOffset is the offset added to hardened path elements
+	hardenedOffset = 0x80000000
+)
+
+// ErrInvalidPathLength is returned when the BIP32 path doesn't have exactly 5 elements
+var ErrInvalidPathLength = errors.New("BIP32 path must contain exactly 5 elements")
+
+// VersionInfo contains app version information.
 type VersionInfo struct {
 	AppMode uint8
 	Major   uint8
 	Minor   uint8
 	Patch   uint8
 }
 
-func (c VersionInfo) String() string {
-	return fmt.Sprintf("%d.%d.%d", c.Major, c.Minor, c.Patch)
+// String returns the version as a string in the format "Major.Minor.Patch".
+func (v VersionInfo) String() string {
+	return fmt.Sprintf("%d.%d.%d", v.Major, v.Minor, v.Patch)
 }
 
-// VersionRequiredError the command is not supported by this app
+// VersionRequiredError indicates that the app version does not meet the minimum requirements.
 type VersionRequiredError struct {
 	Found    VersionInfo
 	Required VersionInfo
 }
 
-func (e VersionRequiredError) Error() string {
-	return fmt.Sprintf("App Version required %s - Version found: %s", e.Required, e.Found)
+// Error implements the error interface for VersionRequiredError.
+func (e *VersionRequiredError) Error() string {
+	return fmt.Sprintf("app version required %s - version found: %s", e.Required, e.Found)
 }
 
-func NewVersionRequiredError(req VersionInfo, ver VersionInfo) error {
+// NewVersionRequiredError creates a new VersionRequiredError.
+func NewVersionRequiredError(required, found VersionInfo) error {
 	return &VersionRequiredError{
-		Found:    ver,
-		Required: req,
+		Found:    found,
+		Required: required,
 	}
 }
 
-// CheckVersion compares the current version with the required version
-func CheckVersion(ver VersionInfo, req VersionInfo) error {
-	if ver.Major != req.Major {
-		if ver.Major > req.Major {
-			return nil
-		}
-		return NewVersionRequiredError(req, ver)
+// CheckVersion compares the current version with the required version.
+// Returns nil if the current version meets or exceeds the required version.
+func CheckVersion(current, required VersionInfo) error {
+	if current.Major > required.Major {
+		return nil
 	}
-
-	if ver.Minor != req.Minor {
-		if ver.Minor > req.Minor {
-			return nil
-		}
-		return NewVersionRequiredError(req, ver)
+	if current.Major < required.Major {
+		return NewVersionRequiredError(required, current)
 	}
 
-	if ver.Patch >= req.Patch {
+	// Major versions are equal, check minor
+	if current.Minor > required.Minor {
 		return nil
 	}
-	return NewVersionRequiredError(req, ver)
-}
-
-func GetBip32bytesv1(bip32Path []uint32, hardenCount int) ([]byte, error) {
-	message := make([]byte, 41)
-	if len(bip32Path) > 10 {
-		return nil, fmt.Errorf("maximum bip32 depth = 10")
+	if current.Minor < required.Minor {
+		return NewVersionRequiredError(required, current)
 	}
-	message[0] = byte(len(bip32Path))
-	for index, element := range bip32Path {
-		pos := 1 + index*4
-		value := element
-		if index < hardenCount {
-			value = 0x80000000 | element
-		}
-		binary.LittleEndian.PutUint32(message[pos:], value)
+
+	// Minor versions are equal, check patch
+	if current.Patch >= required.Patch {
+		return nil
 	}
-	return message, nil
+
+	return NewVersionRequiredError(required, current)
 }
 
-func GetBip32bytesv2(bip44Path []uint32, hardenCount int) ([]byte, error) {
-	message := make([]byte, 20)
-	if len(bip44Path) != 5 {
-		return nil, fmt.Errorf("path should contain 5 elements")
+// GetBip32bytes serializes a BIP32/BIP44 path into bytes for the Ledger device.
+// The path must contain exactly 5 elements. Elements at indices less than hardenCount
+// will be hardened (have 0x80000000 added to them).
+func GetBip32bytes(path []uint32, hardenCount int) ([]byte, error) {
+	if len(path) != bip32PathLength {
+		return nil, ErrInvalidPathLength
 	}
-	for index, element := range bip44Path {
-		pos := index * 4
+
+	result := make([]byte, bip32BytesLength)
+
+	for i, element := range path {
 		value := element
-		if index < hardenCount {
-			value = 0x80000000 | element
+		if i < hardenCount {
+			value |= hardenedOffset
 		}
-		binary.LittleEndian.PutUint32(message[pos:], value)
+		binary.LittleEndian.PutUint32(result[i*4:], value)
 	}
-	return message, nil
+
+	return result, nil
 }