use contract api as a fallback for decoding if signature based fails

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 {