Replace mutex with sync.Map for ABI caching

Author: Amine Afia

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