convert decoded big numbers to strings in api response (#193)

### TL;DR

Added support for converting big numbers to strings in decoded transaction and log data.

### What changed?

- Added a new utility function `ConvertBigNumbersToString` that recursively converts `*big.Int` and `big.Int` values to strings
- Updated the `Serialize` method for `DecodedLog` to convert big numbers to strings in both indexed and non-indexed parameters
- Updated the `Serialize` method for `DecodedTransaction` to convert big numbers to strings in decoded inputs
- Removed unused `StripPayload` function and related helper functions

### How to test?

1. Create a transaction or log that contains big numbers in its decoded data
2. Call the `Serialize` method on the decoded transaction or log
3. Verify that the big numbers are properly converted to strings in the output

### Why make this change?

Big numbers in decoded transaction and log data need to be converted to strings to ensure they can be properly serialized to JSON without precision loss. This is especially important for large numbers that exceed the range of standard JSON number types.

Author: iuwqyir

internal/common/log.go

@@ -252,13 +252,17 @@ func (l *Log) Serialize() LogModel {
 }
 
 func (l *DecodedLog) Serialize() DecodedLogModel {
+	// Convert big numbers to strings in both indexed and non-indexed parameters
+	indexedParams := ConvertBigNumbersToString(l.Decoded.IndexedParams).(map[string]interface{})
+	nonIndexedParams := ConvertBigNumbersToString(l.Decoded.NonIndexedParams).(map[string]interface{})
+
 	return DecodedLogModel{
 		LogModel: l.Log.Serialize(),
 		Decoded: DecodedLogDataModel{
 			Name:             l.Decoded.Name,
 			Signature:        l.Decoded.Signature,
-			IndexedParams:    l.Decoded.IndexedParams,
-			NonIndexedParams: l.Decoded.NonIndexedParams,
+			IndexedParams:    indexedParams,
+			NonIndexedParams: nonIndexedParams,
 		},
 	}
 }

internal/common/transaction.go

@@ -229,12 +229,15 @@ func (t *Transaction) Serialize() TransactionModel {
 }
 
 func (t *DecodedTransaction) Serialize() DecodedTransactionModel {
+	// Convert big numbers to strings in the decoded inputs
+	decodedInputs := ConvertBigNumbersToString(t.Decoded.Inputs).(map[string]interface{})
+
 	return DecodedTransactionModel{
 		TransactionModel: t.Transaction.Serialize(),
 		Decoded: DecodedTransactionDataModel{
 			Name:      t.Decoded.Name,
 			Signature: t.Decoded.Signature,
-			Inputs:    t.Decoded.Inputs,
+			Inputs:    decodedInputs,
 		},
 	}
 }

internal/common/utils.go

@@ -5,7 +5,6 @@ import (
 	"math/big"
 	"regexp"
 	"strings"
-	"unicode"
 )
 
 func BigIntSliceToChunks(values []*big.Int, chunkSize int) [][]*big.Int {
@@ -23,143 +22,6 @@ func BigIntSliceToChunks(values []*big.Int, chunkSize int) [][]*big.Int {
 	return chunks
 }
 
-// StripPayload removes parameter names, 'indexed' keywords,
-// and extra whitespaces from a Solidity function or event signature.
-func StripPayload(signature string) string {
-	// Find the index of the first '(' and last ')'
-	start := strings.Index(signature, "(")
-	end := strings.LastIndex(signature, ")")
-	if start == -1 || end == -1 || end <= start {
-		// Return the original signature if it doesn't match the expected pattern
-		return signature
-	}
-
-	functionName := strings.TrimSpace(signature[:start])
-	paramsStr := signature[start+1 : end]
-
-	// Parse parameters
-	strippedParams := parseParameters(paramsStr)
-
-	// Reconstruct the cleaned-up signature
-	strippedSignature := fmt.Sprintf("%s(%s)", functionName, strings.Join(strippedParams, ","))
-	return strippedSignature
-}
-
-// parseParameters parses the parameter string and returns a slice of cleaned-up parameter types
-func parseParameters(paramsStr string) []string {
-	var params []string
-	var currentParam strings.Builder
-	bracketDepth := 0
-	var inType bool // Indicates if we are currently parsing a type
-
-	runes := []rune(paramsStr)
-	i := 0
-	for i < len(runes) {
-		char := runes[i]
-		switch char {
-		case '(', '[', '{':
-			bracketDepth++
-			inType = true
-			currentParam.WriteRune(char)
-			i++
-		case ')', ']', '}':
-			bracketDepth--
-			currentParam.WriteRune(char)
-			i++
-		case ',':
-			if bracketDepth == 0 {
-				// End of current parameter
-				paramType := cleanType(currentParam.String())
-				if paramType != "" {
-					params = append(params, paramType)
-				}
-				currentParam.Reset()
-				inType = false
-				i++
-			} else {
-				currentParam.WriteRune(char)
-				i++
-			}
-		case ' ':
-			if inType {
-				currentParam.WriteRune(char)
-			}
-			i++
-		default:
-			// Check if the word is a keyword to ignore
-			if unicode.IsLetter(char) {
-				wordStart := i
-				for i < len(runes) && (unicode.IsLetter(runes[i]) || unicode.IsDigit(runes[i])) {
-					i++
-				}
-				word := string(runes[wordStart:i])
-
-				// Ignore 'indexed' and parameter names
-				if isType(word) {
-					inType = true
-					currentParam.WriteString(word)
-				} else if word == "indexed" {
-					// Skip 'indexed'
-					inType = false
-				} else {
-					// Ignore parameter names
-					if inType {
-						// If we are in the middle of parsing a type and encounter a parameter name, skip it
-						inType = false
-					}
-				}
-			} else {
-				if inType {
-					currentParam.WriteRune(char)
-				}
-				i++
-			}
-		}
-	}
-
-	// Add the last parameter
-	if currentParam.Len() > 0 {
-		paramType := cleanType(currentParam.String())
-		if paramType != "" {
-			params = append(params, paramType)
-		}
-	}
-
-	return params
-}
-
-// cleanType cleans up a parameter type string by removing extra spaces and 'tuple' keyword
-func cleanType(param string) string {
-	// Remove 'tuple' keyword
-	param = strings.ReplaceAll(param, "tuple", "")
-	// Remove 'indexed' keyword
-	param = strings.ReplaceAll(param, "indexed", "")
-	// Remove any parameter names (already handled in parsing)
-	param = strings.TrimSpace(param)
-	// Remove extra whitespaces
-	param = strings.Join(strings.Fields(param), "")
-	return param
-}
-
-// isType checks if a word is a Solidity type
-func isType(word string) bool {
-	if strings.HasPrefix(word, "uint") || strings.HasPrefix(word, "int") {
-		return true
-	}
-	types := map[string]bool{
-		"address":  true,
-		"bool":     true,
-		"string":   true,
-		"bytes":    true,
-		"fixed":    true,
-		"ufixed":   true,
-		"function": true,
-		// Add other types as needed
-	}
-
-	return types[word]
-}
-
 var allowedFunctions = map[string]struct{}{
 	"sum":                  {},
 	"count":                {},
@@ -217,3 +79,35 @@ func ValidateQuery(query string) error {
 
 	return nil
 }
+
+func ConvertBigNumbersToString(data interface{}) interface{} {
+	switch v := data.(type) {
+	case map[string]interface{}:
+		for key, value := range v {
+			v[key] = ConvertBigNumbersToString(value)
+		}
+		return v
+	case []interface{}:
+		for i, value := range v {
+			v[i] = ConvertBigNumbersToString(value)
+		}
+		return v
+	case []*big.Int:
+		result := make([]string, len(v))
+		for i, num := range v {
+			if num == nil {
+				result[i] = "0"
+			} else {
+				result[i] = num.String()
+			}
+		}
+		return result
+	case *big.Int:
+		if v == nil {
+			return "0"
+		}
+		return v.String()
+	default:
+		return v
+	}
+}