Replace mutex with sync.Map for ABI caching (#218)

### TL;DR

Replace mutex-protected map with sync.Map for ABI caching to improve concurrency.

### What changed?

- Replaced the manual mutex-protected map implementation with Go's built-in `sync.Map` for ABI caching
- Modified `GetABIForContractWithCache` to use `sync.Map` methods (`Load`, `Store`) instead of manual locking
- Removed mutex parameters from function signatures in `DecodeLogs` and `DecodeTransactions`
- Simplified the concurrent processing of logs and transactions by eliminating explicit mutex handling

### How to test?

1. Run concurrent processing of logs and transactions to verify that ABI caching works correctly
2. Verify that decoded logs and transactions contain the expected data
3. Check for any race conditions or deadlocks that might have been introduced

### Why make this change?

The previous implementation used a manual mutex to protect a map during concurrent access, which can lead to contention and reduced performance. `sync.Map` is specifically designed for concurrent use cases where items are frequently read but infrequently updated, which matches the ABI caching pattern. This change improves code safety and performance by using a more appropriate concurrency primitive.

<!-- This is an auto-generated comment: release notes by coderabbit.ai -->
## Summary by CodeRabbit

- **Refactor**
  - Improved concurrency handling for ABI caching, resulting in more reliable and efficient processing of logs and transactions.
  - Simplified internal logic for decoding logs and transactions, reducing potential synchronization issues.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: iuwqyir

internal/common/abi.go

@@ -34,23 +34,20 @@ func getHTTPClient() *http.Client {
 	return httpClient
 }
 
-func GetABIForContractWithCache(chainId string, contract string, abiCache map[string]*abi.ABI, mut *sync.Mutex) *abi.ABI {
-	abi, ok := abiCache[contract]
-	if !ok {
-		abiResult, err := GetABIForContract(chainId, contract)
-		if err != nil {
-			mut.Lock()
-			abiCache[contract] = nil
-			mut.Unlock()
-			return nil
-		} else {
-			mut.Lock()
-			abiCache[contract] = abiResult
-			mut.Unlock()
-			abi = abiResult
+func GetABIForContractWithCache(chainId string, contract string, abiCache *sync.Map) *abi.ABI {
+	if abiValue, ok := abiCache.Load(contract); ok {
+		if abi, ok := abiValue.(*abi.ABI); ok {
+			return abi
 		}
 	}
-	return abi
+
+	abiResult, err := GetABIForContract(chainId, contract)
+	if err != nil {
+		abiCache.Store(contract, nil)
+		return nil
+	}
+	abiCache.Store(contract, abiResult)
+	return abiResult
 }
 
 func GetABIForContract(chainId string, contract string) (*abi.ABI, error) {

internal/common/log.go

@@ -87,11 +87,11 @@ type DecodedLog struct {
 
 func DecodeLogs(chainId string, logs []Log) []*DecodedLog {
 	decodedLogs := make([]*DecodedLog, len(logs))
-	abiCache := make(map[string]*abi.ABI)
+	abiCache := &sync.Map{}
 
-	decodeLogFunc := func(eventLog *Log, mut *sync.Mutex) *DecodedLog {
+	decodeLogFunc := func(eventLog *Log) *DecodedLog {
 		decodedLog := DecodedLog{Log: *eventLog}
-		abi := GetABIForContractWithCache(chainId, eventLog.Address, abiCache, mut)
+		abi := GetABIForContractWithCache(chainId, eventLog.Address, abiCache)
 		if abi == nil {
 			return &decodedLog
 		}
@@ -108,27 +108,26 @@ func DecodeLogs(chainId string, logs []Log) []*DecodedLog {
 	}
 
 	var wg sync.WaitGroup
-	var mut sync.Mutex
 	for idx, eventLog := range logs {
 		wg.Add(1)
-		go func(idx int, eventLog Log, mut *sync.Mutex) {
+		go func(idx int, eventLog Log) {
 			defer func() {
 				if err := recover(); err != nil {
 					log.Error().
 						Any("chainId", chainId).
-						Any("Logs", logs).
-						Int("logIndex", idx).
+						Str("txHash", eventLog.TransactionHash).
+						Uint64("logIndex", eventLog.LogIndex).
 						Str("logAddress", eventLog.Address).
 						Str("logTopic0", eventLog.Topic0).
 						Err(fmt.Errorf("%v", err)).
 						Msg("Caught panic in DecodeLogs, possibly in decodeLogFunc")
+					decodedLogs[idx] = &DecodedLog{Log: eventLog}
 				}
-				decodedLogs[idx] = &DecodedLog{Log: eventLog}
 			}()
 			defer wg.Done()
-			decodedLog := decodeLogFunc(&eventLog, mut)
+			decodedLog := decodeLogFunc(&eventLog)
 			decodedLogs[idx] = decodedLog
-		}(idx, eventLog, &mut)
+		}(idx, eventLog)
 	}
 	wg.Wait()
 	return decodedLogs

internal/common/transaction.go

@@ -110,10 +110,10 @@ type DecodedTransactionModel struct {
 
 func DecodeTransactions(chainId string, txs []Transaction) []*DecodedTransaction {
 	decodedTxs := make([]*DecodedTransaction, len(txs))
-	abiCache := make(map[string]*abi.ABI)
-	decodeTxFunc := func(transaction *Transaction, mut *sync.Mutex) *DecodedTransaction {
+	abiCache := &sync.Map{}
+	decodeTxFunc := func(transaction *Transaction) *DecodedTransaction {
 		decodedTransaction := DecodedTransaction{Transaction: *transaction}
-		abi := GetABIForContractWithCache(chainId, transaction.ToAddress, abiCache, mut)
+		abi := GetABIForContractWithCache(chainId, transaction.ToAddress, abiCache)
 		if abi == nil {
 			return &decodedTransaction
 		}
@@ -139,14 +139,13 @@ func DecodeTransactions(chainId string, txs []Transaction) []*DecodedTransaction
 	}
 
 	var wg sync.WaitGroup
-	mut := &sync.Mutex{}
 	for idx, transaction := range txs {
 		wg.Add(1)
-		go func(idx int, transaction Transaction, mut *sync.Mutex) {
+		go func(idx int, transaction Transaction) {
 			defer wg.Done()
-			decodedTx := decodeTxFunc(&transaction, mut)
+			decodedTx := decodeTxFunc(&transaction)
 			decodedTxs[idx] = decodedTx
-		}(idx, transaction, mut)
+		}(idx, transaction)
 	}
 	wg.Wait()
 	return decodedTxs