feat: add base58 output format and escape sequence processing

- Add base58 output format for Solana signature compatibility
- Implement escape sequence processing (\n, \t, \r, \, ", \')
- Fix newline handling in messages for proper wallet verification
- Add comprehensive tests for escape sequence processing
- Remove duplicate base58Encode function from tests

This fixes signature verification issues where backends expect base58 format
and properly handles multiline messages with actual newlines instead of literal \n

Author: Aryamanraj

go-sol-sign

@@ -4,11 +4,12 @@
 // sign messages using Ed25519 private keys in the standard Solana keypair format.
 //
 // Usage:
-//   go-sol-sign -keypair <path> -message <message> [-format base64|hex]
+//   go-sol-sign -keypair <path> -message <message> [-format base64|hex|base58]
 //
 // Examples:
 //   go-sol-sign -keypair ~/.config/solana/id.json -message "Hello World"
 //   go-sol-sign -keypair ./keypair.json -message "Test" -format hex
+//   go-sol-sign -private-key "base58key" -message "Test" -format base58
 package main
 
 import (
@@ -40,7 +41,7 @@ func main() {
 		privateKey   = flag.String("private-key", "", "Private key as base58 string (alternative to -keypair)")
 		message      = flag.String("message", "", "Message to sign")
 		messageFile  = flag.String("message-file", "", "Path to file containing message to sign")
-		outputFormat = flag.String("format", "base64", "Output format: base64, hex")
+		outputFormat = flag.String("format", "base64", "Output format: base64, hex, base58")
 		version      = flag.Bool("version", false, "Show version information")
 		verbose      = flag.Bool("verbose", false, "Enable verbose output")
 	)
@@ -76,7 +77,7 @@ func main() {
 	}
 
 	if *message != "" {
-		messageText = *message
+		messageText = processEscapeSequences(*message)
 	} else if *messageFile != "" {
 		data, err := os.ReadFile(*messageFile)
 		if err != nil {
@@ -148,11 +149,26 @@ func main() {
 		fmt.Println(base64.StdEncoding.EncodeToString(signature))
 	case "hex":
 		fmt.Println(hex.EncodeToString(signature))
+	case "base58":
+		fmt.Println(base58Encode(signature))
 	default:
-		log.Fatalf("Unknown format: %s. Supported formats: base64, hex", *outputFormat)
+		log.Fatalf("Unknown format: %s. Supported formats: base64, hex, base58", *outputFormat)
 	}
 }
 
+// processEscapeSequences converts escape sequences like \n, \t, etc. to actual characters
+func processEscapeSequences(input string) string {
+	// Handle common escape sequences
+	result := input
+	result = strings.ReplaceAll(result, "\\n", "\n")
+	result = strings.ReplaceAll(result, "\\t", "\t")
+	result = strings.ReplaceAll(result, "\\r", "\r")
+	result = strings.ReplaceAll(result, "\\\\", "\\")
+	result = strings.ReplaceAll(result, "\\\"", "\"")
+	result = strings.ReplaceAll(result, "\\'", "'")
+	return result
+}
+
 // printUsage displays usage information
 func printUsage() {
 	fmt.Printf("%s v%s - %s\n\n", ToolName, Version, ToolDescription)
@@ -167,14 +183,15 @@ func printUsage() {
 	fmt.Println("  -message-file string Path to file containing message")
 	fmt.Println("")
 	fmt.Println("Other Options:")
-	fmt.Println("  -format string       Output format: base64, hex (default: base64)")
+	fmt.Println("  -format string       Output format: base64, hex, base58 (default: base64)")
 	fmt.Println("  -verbose             Enable verbose output")
 	fmt.Println("  -version             Show version information")
 	fmt.Println("")
 	fmt.Println("Examples:")
 	fmt.Printf("  %s -keypair ~/.config/solana/id.json -message \"Hello World\"\n", ToolName)
 	fmt.Printf("  %s -private-key 3yD2... -message \"Test\" -format hex\n", ToolName)
 	fmt.Printf("  %s -keypair ./keypair.json -message-file ./message.txt\n", ToolName)
+	fmt.Printf("  %s -private-key 3yD2... -message \"Test\" -format base58\n", ToolName)
 	fmt.Printf("  %s -version\n", ToolName)
 }
 
@@ -294,3 +311,46 @@ func base58Decode(s string) ([]byte, error) {
 
 	return result, nil
 }
+
+// Simple base58 encoder for Solana signatures
+func base58Encode(input []byte) string {
+	const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+	
+	if len(input) == 0 {
+		return ""
+	}
+	
+	// Count leading zeros
+	leadingZeros := 0
+	for i := 0; i < len(input) && input[i] == 0; i++ {
+		leadingZeros++
+	}
+	
+	// Convert to base58
+	var result []byte
+	for i := leadingZeros; i < len(input); i++ {
+		carry := int(input[i])
+		for j := 0; j < len(result); j++ {
+			carry += int(result[j]) * 256
+			result[j] = byte(carry % 58)
+			carry /= 58
+		}
+		
+		for carry > 0 {
+			result = append(result, byte(carry%58))
+			carry /= 58
+		}
+	}
+	
+	// Convert to alphabet characters
+	var encoded []byte
+	for i := 0; i < leadingZeros; i++ {
+		encoded = append(encoded, '1')
+	}
+	
+	for i := len(result) - 1; i >= 0; i-- {
+		encoded = append(encoded, alphabet[result[i]])
+	}
+	
+	return string(encoded)
+}

main.go

@@ -294,54 +294,26 @@ func TestBase58Decode(t *testing.T) {
 	}
 }
 
-// Helper function to encode bytes to base58 (for testing)
-func base58Encode(data []byte) string {
-	const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-	
-	if len(data) == 0 {
-		return ""
-	}
-	
-	// Convert to big integer
-	var result []byte
-	
-	// Count leading zeros
-	leadingZeros := 0
-	for i := 0; i < len(data) && data[i] == 0; i++ {
-		leadingZeros++
+// TestEscapeSequenceProcessing tests that escape sequences are properly converted
+func TestEscapeSequenceProcessing(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"Hello\\nWorld", "Hello\nWorld"},
+		{"Hello\\tWorld", "Hello\tWorld"},
+		{"Hello\\rWorld", "Hello\rWorld"},
+		{"Hello\\\\World", "Hello\\World"},
+		{"Hello\\\"World", "Hello\"World"},
+		{"Hello\\'World", "Hello'World"},
+		{"No escapes", "No escapes"},
+		{"Multiple\\nlines\\nhere", "Multiple\nlines\nhere"},
 	}
 
-	// Convert
-	input := make([]byte, len(data))
-	copy(input, data)
-	
-	for len(input) > 0 {
-		// Find first non-zero
-		i := 0
-		for i < len(input) && input[i] == 0 {
-			i++
+	for _, test := range tests {
+		result := processEscapeSequences(test.input)
+		if result != test.expected {
+			t.Errorf("processEscapeSequences(%q) = %q, want %q", test.input, result, test.expected)
 		}
-		input = input[i:]
-		
-		if len(input) == 0 {
-			break
-		}
-		
-		// Divide by 58
-		remainder := 0
-		for i := 0; i < len(input); i++ {
-			temp := remainder*256 + int(input[i])
-			input[i] = byte(temp / 58)
-			remainder = temp % 58
-		}
-		
-		result = append([]byte{alphabet[remainder]}, result...)
 	}
-	
-	// Add leading 1s for leading zeros
-	for i := 0; i < leadingZeros; i++ {
-		result = append([]byte{'1'}, result...)
-	}
-	
-	return string(result)
 }