FIX: After review pt 2

Author: mariusmihaic

cmd/proxy/config/config.toml

@@ -18,7 +18,7 @@
    # before it should be updated
    EconomicsMetricsCacheValidityDurationSec = 600 # 10 minutes
 
-   # BlockCacheDurationSec defines how long block/hyperblock results(queried by hash or nonce) are kept in cache, in seconds.
+   # BlockCacheDurationSec defines how long block/hyperblock results (queried by hash or nonce) are kept in cache, in seconds.
    BlockCacheDurationSec = 30
 
    # BalancedObservers - if this flag is set to true, then the requests will be distributed equally between observers.

process/blockProcessorCache.go

@@ -14,9 +14,20 @@ type cacheableBlock interface {
 // These caching errors should never happen, and if they do, they should not be blocking
 
 func (bp *BlockProcessor) cacheObject(obj cacheableBlock, scope string, opts interface{}) {
-	objKey := makeObjKey(scope, obj.Hash(), opts)
-	hashLookupKey := makeHashCacheKey(scope, obj.Hash(), opts)
-	nonceLookupKey := makeNonceCacheKey(scope, obj.Nonce(), opts)
+	objKey, err := makeObjKey(scope, obj.Hash(), opts)
+	if err != nil {
+		return
+	}
+
+	hashLookupKey, err := makeHashCacheKey(scope, obj.Hash(), opts)
+	if err != nil {
+		return
+	}
+
+	nonceLookupKey, err := makeNonceCacheKey(scope, obj.Nonce(), opts)
+	if err != nil {
+		return
+	}
 
 	// Store object
 	_ = bp.cache.Put(objKey, obj, 0)
@@ -26,27 +37,51 @@ func (bp *BlockProcessor) cacheObject(obj cacheableBlock, scope string, opts int
 	_ = bp.cache.Put(nonceLookupKey, objKey, 0)
 }
 
-func makeObjKey(scope string, hash string, opts interface{}) []byte {
-	optBytes, _ := json.Marshal(opts)
-	return []byte(fmt.Sprintf("%s:%s|opts:%s", scope, hash, string(optBytes)))
+func makeObjKey(scope string, hash string, opts interface{}) ([]byte, error) {
+	optBytes, err := json.Marshal(opts)
+	if err != nil {
+		log.Error("makeObjKey", "error", err)
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("%s:%s|opts:%s", scope, hash, string(optBytes))), nil
 }
 
-func makeHashCacheKey(scope string, hash string, opts interface{}) []byte {
-	optBytes, _ := json.Marshal(opts)
-	return []byte(fmt.Sprintf("%s:hash:%s|opts:%s", scope, hash, string(optBytes)))
+func makeHashCacheKey(scope string, hash string, opts interface{}) ([]byte, error) {
+	optBytes, err := json.Marshal(opts)
+	if err != nil {
+		log.Error("makeHashCacheKey", "error", err)
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("%s:hash:%s|opts:%s", scope, hash, string(optBytes))), nil
 }
 
-func makeNonceCacheKey(scope string, nonce uint64, opts interface{}) []byte {
-	optBytes, _ := json.Marshal(opts)
-	return []byte(fmt.Sprintf("%s:nonce:%d|opts:%s", scope, nonce, string(optBytes)))
+func makeNonceCacheKey(scope string, nonce uint64, opts interface{}) ([]byte, error) {
+	optBytes, err := json.Marshal(opts)
+	if err != nil {
+		log.Error("makeNonceCacheKey", "error", err)
+		return nil, err
+	}
+	return []byte(fmt.Sprintf("%s:nonce:%d|opts:%s", scope, nonce, string(optBytes))), nil
 }
 
 func getObjectFromCacheWithHash[T cacheableBlock](c TimedCache, scope string, hash string, opts interface{}) T {
-	return getObjFromCache[T](c, makeHashCacheKey(scope, hash, opts))
+	var nilRet T
+	hashKey, err := makeHashCacheKey(scope, hash, opts)
+	if err != nil {
+		return nilRet
+	}
+
+	return getObjFromCache[T](c, hashKey)
 }
 
 func getObjectFromCacheWithNonce[T cacheableBlock](c TimedCache, scope string, nonce uint64, opts interface{}) T {
-	return getObjFromCache[T](c, makeNonceCacheKey(scope, nonce, opts))
+	var nilRet T
+	nonceKey, err := makeNonceCacheKey(scope, nonce, opts)
+	if err != nil {
+		return nilRet
+	}
+
+	return getObjFromCache[T](c, nonceKey)
 }
 
 func getObjFromCache[T cacheableBlock](c TimedCache, lookUpKey []byte) T {

process/blockProcessorCache_test.go

@@ -15,10 +15,12 @@ import (
 
 func getObjectFromCache[T cacheableBlock](c TimedCache, scope string, hash string, nonce *uint64, opts interface{}) T {
 	if hash != "" {
-		return getObjFromCache[T](c, makeHashCacheKey(scope, hash, opts))
+		hashKey, _ := makeHashCacheKey(scope, hash, opts)
+		return getObjFromCache[T](c, hashKey)
 	}
 
-	return getObjFromCache[T](c, makeNonceCacheKey(scope, *nonce, opts))
+	nonceKey, _ := makeNonceCacheKey(scope, *nonce, opts)
+	return getObjFromCache[T](c, nonceKey)
 }
 
 func TestBlockProcessorCache(t *testing.T) {