Change from Load and then Store to LoadOrStore

protocol/rpcconsumer/rpcconsumer.go

@@ -239,36 +239,34 @@ func (rpcc *RPCConsumer) Start(ctx context.Context, options *rpcConsumerStartOpt
 				var loaded bool
 				var err error
 
-				optimizer, loaded, err = optimizers.Load(chainID)
+				baseLatency := common.AverageWorldLatency / 2 // we want performance to be half our timeout or better
+				tempOptimizer := provideroptimizer.NewProviderOptimizer(options.strategy, averageBlockTime, baseLatency, options.maxConcurrentProviders)
+				optimizer, loaded, err = optimizers.LoadOrStore(chainID, tempOptimizer)
 				if err != nil {
 					optimizer = nil
 					return utils.LavaFormatError("failed loading optimizer", err, utils.LogAttr("endpoint", rpcEndpoint.Key()))
 				}
-				if !loaded {
-					// doesn't exist for this chain create a new one
-					baseLatency := common.AverageWorldLatency / 2 // we want performance to be half our timeout or better
-					optimizer = provideroptimizer.NewProviderOptimizer(options.strategy, averageBlockTime, baseLatency, options.maxConcurrentProviders)
-					optimizers.Store(chainID, optimizer)
+				if !loaded { // stored, use the new one
+					optimizer = tempOptimizer
 				}
 
-				consumerConsistency, loaded, err = consumerConsistencies.Load(chainID)
+				tempConsumerConsistency := NewConsumerConsistency(chainID)
+				consumerConsistency, loaded, err = consumerConsistencies.LoadOrStore(chainID, tempConsumerConsistency)
 				if err != nil {
 					return utils.LavaFormatError("failed loading consumer consistency", err, utils.LogAttr("endpoint", rpcEndpoint.Key()))
 				}
-				if !loaded { // doesn't exist for this chain create a new one
-					consumerConsistency = NewConsumerConsistency(chainID)
-					consumerConsistencies.Store(chainID, consumerConsistency)
+				if !loaded { // stored, use the new one
+					consumerConsistency = tempConsumerConsistency
 				}
 
-				finalizationConsensus, loaded, err = finalizationConsensuses.Load(chainID)
+				tempFinalizationConsensus := finalizationconsensus.NewFinalizationConsensus(rpcEndpoint.ChainID)
+				finalizationConsensus, loaded, err = finalizationConsensuses.LoadOrStore(chainID, tempFinalizationConsensus)
 				if err != nil {
 					return utils.LavaFormatError("failed loading finalization consensus", err, utils.LogAttr("endpoint", rpcEndpoint.Key()))
 				}
-				if !loaded {
-					// doesn't exist for this chain create a new one
-					finalizationConsensus = finalizationconsensus.NewFinalizationConsensus(rpcEndpoint.ChainID)
+				if !loaded { // stored, use the new one
+					finalizationConsensus = tempFinalizationConsensus
 					consumerStateTracker.RegisterFinalizationConsensusForUpdates(ctx, finalizationConsensus)
-					finalizationConsensuses.Store(chainID, finalizationConsensus)
 				}
 				return nil
 			}