Usage of Shared Cache for Synthetic transaction receipts (#1729)

* - Refactored getBlock and eth_getTransactionReceipt to use Shared Cache when working with synthetic receipts for HTS transactions.
- Added Unit Tests where needed.

Signed-off-by: Alfredo Gutierrez <[email protected]>

* - Fix tests

Signed-off-by: Alfredo Gutierrez <[email protected]>

---------

Signed-off-by: Alfredo Gutierrez <[email protected]>

Author: AlfredoG87

packages/relay/src/lib/eth.ts

@@ -1745,7 +1745,11 @@ export class EthImpl implements Eth {
     }
 
     const cacheKeySyntheticLog = `${constants.CACHE_KEY.SYNTHETIC_LOG_TRANSACTION_HASH}${hash}`;
-    const cachedLog = this.cacheService.get(cacheKeySyntheticLog, EthImpl.ethGetTransactionReceipt, requestIdPrefix);
+    const cachedLog = await this.cacheService.getSharedWithFallback(
+      cacheKeySyntheticLog,
+      EthImpl.ethGetTransactionReceipt,
+      requestIdPrefix,
+    );
     if (cachedLog) {
       const receipt: any = {
         blockHash: cachedLog.blockHash,
@@ -2000,15 +2004,29 @@ export class EthImpl implements Eth {
         transactionArray.push(transaction);
 
         const cacheKey = `${constants.CACHE_KEY.SYNTHETIC_LOG_TRANSACTION_HASH}${log.transactionHash}`;
-        this.cacheService.set(cacheKey, log, EthImpl.ethGetBlockByHash, this.syntheticLogCacheTtl, requestIdPrefix);
+        this.cacheService.set(
+          cacheKey,
+          log,
+          EthImpl.ethGetBlockByHash,
+          this.syntheticLogCacheTtl,
+          requestIdPrefix,
+          true,
+        );
       });
     } else {
       filteredLogs = logs.filter((log) => !transactionArray.includes(log.transactionHash));
       filteredLogs.forEach((log) => {
         transactionArray.push(log.transactionHash);
 
         const cacheKey = `${constants.CACHE_KEY.SYNTHETIC_LOG_TRANSACTION_HASH}${log.transactionHash}`;
-        this.cacheService.set(cacheKey, log, EthImpl.ethGetBlockByHash, this.syntheticLogCacheTtl, requestIdPrefix);
+        this.cacheService.set(
+          cacheKey,
+          log,
+          EthImpl.ethGetBlockByHash,
+          this.syntheticLogCacheTtl,
+          requestIdPrefix,
+          true,
+        );
       });
 
       this.logger.trace(

packages/relay/src/lib/services/cacheService/cacheService.ts

@@ -148,6 +148,21 @@ export class CacheService {
     }
   }
 
+  /**
+   * If SharedCacheEnabled will use shared, otherwise will fallback to internal cache.
+   * @param {string} key - The cache key.
+   * @param {string} callingMethod - The name of the calling method.
+   * @param {string} [requestIdPrefix] - The optional request ID prefix.
+   * @returns {Promise<any>} A Promise that resolves with the cached value or null if not found.
+   */
+  public getSharedWithFallback(key: string, callingMethod: string, requestIdPrefix?: string): any {
+    if (this.isSharedCacheEnabled) {
+      return this.getAsync(key, callingMethod, requestIdPrefix);
+    } else {
+      return this.get(key, callingMethod, requestIdPrefix);
+    }
+  }
+
   /**
    * Retrieves a value from the internal cache.
    *

packages/relay/tests/lib/ethGetBlockBy.spec.ts

@@ -34,6 +34,7 @@ import HbarLimit from '../../src/lib/hbarlimiter';
 import { Log, Transaction } from '../../src/lib/model';
 import { nullableNumberTo0x, numberTo0x, nanOrNumberTo0x, toHash32 } from '../../../../packages/relay/src/formatters';
 import { CacheService } from '../../src/lib/services/cacheService/cacheService';
+import * as sinon from 'sinon';
 
 const LRU = require('lru-cache');
 
@@ -260,6 +261,7 @@ const defaultNetworkFees = {
 describe('eth_getBlockBy', async function () {
   this.timeout(10000);
   let ethImpl: EthImpl;
+  const sandbox = sinon.createSandbox();
 
   this.beforeAll(() => {
     cacheService = new CacheService(logger.child({ name: `cache` }), registry);
@@ -294,6 +296,11 @@ describe('eth_getBlockBy', async function () {
     // reset cache and restMock
     cacheService.clear();
     restMock.reset();
+    sandbox.spy(cacheService, 'set');
+  });
+
+  afterEach(function () {
+    sandbox.restore();
   });
 
   const mirrorLogToModelLog = (mirrorLog) => {
@@ -432,6 +439,18 @@ describe('eth_getBlockBy', async function () {
     const cacheKeySyntheticLog2 = `${constants.CACHE_KEY.SYNTHETIC_LOG_TRANSACTION_HASH}${modelLog2.transactionHash}`;
     const cacheKeySyntheticLog3 = `${constants.CACHE_KEY.SYNTHETIC_LOG_TRANSACTION_HASH}${modelLog3.transactionHash}`;
 
+    function verifySharedCacheWasUsed() {
+      // verify shared cache was selected
+      const txCount = referenceLogs.length;
+      // @ts-ignore - spy
+      expect(cacheService.set.callCount).to.equal(txCount);
+      // @ts-ignore - spy
+      for (let i = 0; i < txCount; i++) {
+        // @ts-ignore - spy
+        expect(cacheService.set.getCall(i).args[5], 'shared cache should be used').to.equal(true);
+      }
+    }
+
     it('filterAndPopulateSyntheticContractResults showDetails=false sets cache', async function () {
       expect(cacheService.get(cacheKeySyntheticLog1, '', '')).to.be.null;
       expect(cacheService.get(cacheKeySyntheticLog2, '', '')).to.be.null;
@@ -442,6 +461,7 @@ describe('eth_getBlockBy', async function () {
       expect(cacheService.get(cacheKeySyntheticLog1, '', '')).to.be.equal(modelLog1);
       expect(cacheService.get(cacheKeySyntheticLog2, '', '')).to.be.equal(modelLog2);
       expect(cacheService.get(cacheKeySyntheticLog3, '', '')).to.be.equal(modelLog3);
+      verifySharedCacheWasUsed();
     });
 
     it('filterAndPopulateSyntheticContractResults showDetails=true sets cache', async function () {
@@ -454,6 +474,7 @@ describe('eth_getBlockBy', async function () {
       expect(cacheService.get(cacheKeySyntheticLog1, '', '')).to.be.equal(modelLog1);
       expect(cacheService.get(cacheKeySyntheticLog2, '', '')).to.be.equal(modelLog2);
       expect(cacheService.get(cacheKeySyntheticLog3, '', '')).to.be.equal(modelLog3);
+      verifySharedCacheWasUsed();
     });
   });
 });

packages/relay/tests/lib/services/cacheService/cacheService.spec.ts

@@ -66,6 +66,16 @@ describe('CacheService Test Suite', async function () {
 
       expect(cachedValue).to.be.null;
     });
+
+    it('should be able to get from internal cache when calling getSharedWithFallback', async function () {
+      const key = 'string';
+      const value = 'value';
+
+      cacheService.set(key, value, callingMethod, undefined, undefined, true);
+      const cachedValue = cacheService.getSharedWithFallback(key, callingMethod);
+
+      expect(cachedValue).eq(value);
+    });
   });
 
   describe('Shared Cache Test Suite', async function () {
@@ -109,5 +119,17 @@ describe('CacheService Test Suite', async function () {
 
       expect(cachedValue).to.be.null;
     });
+
+    it('should be able to get from shared cache with fallback to internal cache', async function () {
+      const key = 'string';
+      const value = 'value';
+
+      cacheService.set(key, value, callingMethod, undefined, undefined, true);
+
+      mock.stub(cacheService, 'getAsync').returns(value);
+      const cachedValue = await cacheService.getSharedWithFallback(key, callingMethod, undefined);
+
+      expect(cachedValue).eq(value);
+    });
   });
 });