use contract api as a fallback for decoding if signature based fails (#170)

### TL;DR
Improved transaction and log decoding logic by adding fallback mechanisms and validation checks.

### What changed?
- Extracted decoding logic into separate functions `decodeLogsIfNeeded` and `decodeTransactionsIfNeeded`
- Added validation to check if ABI decoding was successful by verifying name and signature fields
- Implemented fallback to contract service decoding when ABI decoding fails
- Simplified the main handler logic by consolidating decoding paths

### How to test?
1. Test log decoding with valid ABI:
   - Send request with `decode=true` and valid event ABI
   - Verify logs are decoded correctly
2. Test transaction decoding with invalid ABI:
   - Send request with `decode=true` and invalid function ABI
   - Verify fallback to contract service decoding
3. Test with decoding disabled:
   - Send request with `decode=false`
   - Verify raw logs/transactions are returned

### Why make this change?
The previous implementation didn't handle ABI decoding failures gracefully. This change ensures more reliable decoding by validating the results and falling back to the contract service when needed, improving the overall robustness of the API.

Author: iuwqyir

internal/handlers/logs_handlers.go

@@ -179,27 +179,41 @@ func handleLogsRequest(c *gin.Context) {
 			api.InternalErrorHandler(c)
 			return
 		}
-		if eventABI != nil {
-			decodedLogs := []common.DecodedLogModel{}
-			for _, log := range logsResult.Data {
-				decodedLog := log.Decode(eventABI)
-				decodedLogs = append(decodedLogs, decodedLog.Serialize())
-			}
-			queryResult.Data = decodedLogs
+
+		if decodedLogs := decodeLogsIfNeeded(chainId.String(), logsResult.Data, eventABI, config.Cfg.API.AbiDecodingEnabled && queryParams.Decode); decodedLogs != nil {
+			queryResult.Data = serializeDecodedLogs(decodedLogs)
 		} else {
-			if config.Cfg.API.AbiDecodingEnabled && queryParams.Decode {
-				decodedLogs := common.DecodeLogs(chainId.String(), logsResult.Data)
-				queryResult.Data = serializeDecodedLogs(decodedLogs)
-			} else {
-				queryResult.Data = serializeLogs(logsResult.Data)
-			}
+			queryResult.Data = serializeLogs(logsResult.Data)
 		}
+
 		queryResult.Meta.TotalItems = len(logsResult.Data)
 	}
 
 	sendJSONResponse(c, queryResult)
 }
 
+func decodeLogsIfNeeded(chainId string, logs []common.Log, eventABI *abi.Event, useContractService bool) []*common.DecodedLog {
+	if eventABI != nil {
+		decodingCompletelySuccessful := true
+		decodedLogs := []*common.DecodedLog{}
+		for _, log := range logs {
+			decodedLog := log.Decode(eventABI)
+			if decodedLog.Decoded.Name == "" || decodedLog.Decoded.Signature == "" {
+				decodingCompletelySuccessful = false
+			}
+			decodedLogs = append(decodedLogs, decodedLog)
+		}
+		if !useContractService || decodingCompletelySuccessful {
+			// decoding was successful or contract service decoding is disabled
+			return decodedLogs
+		}
+	}
+	if useContractService {
+		return common.DecodeLogs(chainId, logs)
+	}
+	return nil
+}
+
 func getMainStorage() (storage.IMainStorage, error) {
 	storageOnce.Do(func() {
 		var err error

internal/handlers/transactions_handlers.go

@@ -172,27 +172,40 @@ func handleTransactionsRequest(c *gin.Context) {
 			api.InternalErrorHandler(c)
 			return
 		}
-		if functionABI != nil {
-			decodedTransactions := []common.DecodedTransactionModel{}
-			for _, transaction := range transactionsResult.Data {
-				decodedTransaction := transaction.Decode(functionABI)
-				decodedTransactions = append(decodedTransactions, decodedTransaction.Serialize())
-			}
-			queryResult.Data = decodedTransactions
+
+		if decodedTxs := decodeTransactionsIfNeeded(chainId.String(), transactionsResult.Data, functionABI, config.Cfg.API.AbiDecodingEnabled && queryParams.Decode); decodedTxs != nil {
+			queryResult.Data = serializeDecodedTransactions(decodedTxs)
 		} else {
-			if config.Cfg.API.AbiDecodingEnabled && queryParams.Decode {
-				decodedTransactions := common.DecodeTransactions(chainId.String(), transactionsResult.Data)
-				queryResult.Data = serializeDecodedTransactions(decodedTransactions)
-			} else {
-				queryResult.Data = serializeTransactions(transactionsResult.Data)
-			}
+			queryResult.Data = serializeTransactions(transactionsResult.Data)
 		}
 		queryResult.Meta.TotalItems = len(transactionsResult.Data)
 	}
 
 	c.JSON(http.StatusOK, queryResult)
 }
 
+func decodeTransactionsIfNeeded(chainId string, transactions []common.Transaction, functionABI *abi.Method, useContractService bool) []*common.DecodedTransaction {
+	if functionABI != nil {
+		decodingCompletelySuccessful := true
+		decodedTransactions := []*common.DecodedTransaction{}
+		for _, transaction := range transactions {
+			decodedTransaction := transaction.Decode(functionABI)
+			if decodedTransaction.Decoded.Name == "" || decodedTransaction.Decoded.Signature == "" {
+				decodingCompletelySuccessful = false
+			}
+			decodedTransactions = append(decodedTransactions, decodedTransaction)
+		}
+		if !useContractService || decodingCompletelySuccessful {
+			// decoding was successful or contract service decoding is disabled
+			return decodedTransactions
+		}
+	}
+	if useContractService {
+		return common.DecodeTransactions(chainId, transactions)
+	}
+	return nil
+}
+
 func serializeDecodedTransactions(transactions []*common.DecodedTransaction) []common.DecodedTransactionModel {
 	decodedTransactionModels := make([]common.DecodedTransactionModel, len(transactions))
 	for i, transaction := range transactions {