feat(cache): Add redis cache

package.json

@@ -59,6 +59,7 @@
     "@lifi/types": "^8.3.0",
     "dotenv": "^16.3.1",
     "ethers": "^6.7.0",
+    "ioredis": "^5.3.2",
     "pretty-error": "^4.0.0",
     "superagent": "^8.0.9",
     "superagent-throttle": "^1.0.1",

src/abi-cache/abi-cache.test.ts

@@ -6,8 +6,8 @@ import { CacheType, initCache } from './cache'
 let cache: AbiCache
 
 describe('abi-loader', () => {
-  beforeAll(() => {
-    cache = initCache(CacheType.MEMORY)
+  beforeAll(async () => {
+    cache = await initCache(CacheType.MEMORY)
   })
 
   it('load ABIs from the "abis" directory of the file system', () => {

src/abi-cache/abi-cache.ts

@@ -15,14 +15,16 @@ type CachedFunctionFragmentsBySighash = {
 }
 export type ContractLocation = { address: string; chain: ChainId }
 
-export class AbiCache {
+export abstract class AbiCache {
   protected cachedAbis: Map<string, Interface> = new Map()
   protected functionFragments: CachedFunctionFragmentsBySighash = {}
 
   constructor() {
     this.loadAbiDirectory(path.join(__dirname, '../../abis'))
   }
 
+  public abstract init(): Promise<AbiCache>
+
   private groupFunctionFragmentsBySighash = (): void => {
     this.functionFragments = {}
     for (const abi of this.cachedAbis.values()) {
@@ -70,6 +72,19 @@ export class AbiCache {
       })
   }
 
+  protected loadFromString(key: string, abiString: string): void {
+    try {
+      const ethersInterface = new Interface(abiString)
+
+      const location: ContractLocation = this.fromKey(key)
+
+      this.cachedAbis.set(this.toKey(location), ethersInterface)
+      this.groupFunctionFragmentsBySighash()
+    } catch (error) {
+      log().error(`Error parsing string: ${(error as Error).message}`)
+    }
+  }
+
   protected loadFromFile(fileName: string): void {
     try {
       const fileContent = fs.readFileSync(fileName).toString()

src/abi-cache/cache.ts

@@ -1,6 +1,9 @@
+import { RedisOptions } from 'ioredis'
+
 import { AbiCache } from './abi-cache'
 import { FileSystemAbiCache } from './file-system-abi-cache'
 import { MemoryAbiCache } from './memory-abi-cache'
+import { RedisAbiCache } from './redis-abi-cache'
 
 export enum CacheType {
   MEMORY,
@@ -10,17 +13,27 @@ export enum CacheType {
 
 let cache: AbiCache
 
-export const initCache = (cacheType: CacheType): AbiCache => {
+export const initCache = async (
+  cacheType: CacheType,
+  redisOptions?: RedisOptions
+): Promise<AbiCache> => {
   if (!cache) {
     switch (cacheType) {
       case CacheType.FILE_SYSTEM: {
         cache = new FileSystemAbiCache(
           process.env.ABI_DIRECTORY ?? '/tmp/abi-parser'
         )
+        await cache.init()
         break
       }
       case CacheType.MEMORY: {
         cache = new MemoryAbiCache()
+        await cache.init()
+        break
+      }
+      case CacheType.REDIS: {
+        cache = new RedisAbiCache(redisOptions || {})
+        await cache.init()
         break
       }
       default: {

src/abi-cache/file-system-abi-cache.ts

@@ -6,12 +6,17 @@ import { stringify } from '../lib/stringify'
 import { AbiCache, AbiInformation } from './abi-cache'
 
 export class FileSystemAbiCache extends AbiCache {
-  private abiDirectory: string
+  private readonly abiDirectory: string
 
   constructor(abiDirectory: string) {
     super()
     this.abiDirectory = abiDirectory || '/tmp/abi-parser'
+  }
+
+  public override init(): Promise<AbiCache> {
     this.loadAbiDirectory(this.abiDirectory)
+
+    return Promise.resolve(this)
   }
 
   protected override persist(key: string, abi: AbiInformation): void {

src/abi-cache/memory-abi-cache.ts

@@ -7,4 +7,8 @@ export class MemoryAbiCache extends AbiCache {
   protected override persist(key: string, _: AbiInformation): void {
     log().debug(`Using Memory cache, not persisting ABI ${key}`)
   }
+
+  public override init(): Promise<AbiCache> {
+    return Promise.resolve(this)
+  }
 }

src/abi-cache/redis-abi-cache.ts

@@ -0,0 +1,39 @@
+import { Redis, RedisOptions } from 'ioredis'
+
+import { stringify } from '../lib/stringify'
+
+import { AbiCache, AbiInformation } from './abi-cache'
+
+export class RedisAbiCache extends AbiCache {
+  private redis: Redis
+  private cachePrefix = 'ABICACHE:'
+
+  constructor(redisOptions: RedisOptions) {
+    super()
+    this.redis = new Redis({ ...redisOptions, keyPrefix: this.cachePrefix })
+  }
+
+  public override async init(): Promise<AbiCache> {
+    const keys = await this.redis.keys(`${this.cachePrefix}*`)
+
+    await Promise.all(
+      keys.map(async (key: string) => {
+        const abiKey = key.replace(`${this.cachePrefix}`, '')
+        const abi = await this.redis.get(abiKey)
+
+        if (abi) {
+          this.loadFromString(abiKey, abi)
+        }
+      })
+    )
+
+    return Promise.resolve(this)
+  }
+
+  protected override async persist(
+    key: string,
+    abi: AbiInformation
+  ): Promise<void> {
+    await this.redis.set(key, stringify(abi))
+  }
+}

src/cli.ts

@@ -18,7 +18,7 @@ import {
 dotenv.config()
 
 const run = async () => {
-  const cache = initCache(CacheType.FILE_SYSTEM)
+  const cache = await initCache(CacheType.FILE_SYSTEM)
 
   const callDataStrings =
     process.argv.length === 2

src/parse-call-data-string.ts

@@ -1,13 +1,15 @@
-import { AbiCache } from './abi-cache/abi-cache'
-import { CacheType, initCache } from './abi-cache/cache'
-import { cacheCandidates } from './abi-cache/cache-candidates'
+import { AbiCache, CacheType, initCache, cacheCandidates } from './abi-cache'
 import { CallDataInformation } from './parser'
 import { parseCallData } from './parser/calldata-parsers/parse-call-data'
 
 export const parseCallDataString = async (
   callDataString: string,
-  cache: AbiCache = initCache(CacheType.MEMORY)
+  abiCache?: AbiCache
 ): Promise<CallDataInformation[]> => {
+  const cache: AbiCache = abiCache
+    ? abiCache
+    : await initCache(CacheType.MEMORY)
+
   const parsedCandidates: CallDataInformation[] = parseCallData(
     callDataString,
     cache

src/parser/parser.acceptance.test.ts

@@ -1,7 +1,6 @@
 import { AbiCoder } from 'ethers'
 
-import { AbiCache } from '../abi-cache/abi-cache'
-import { CacheType, initCache } from '../abi-cache/cache'
+import { AbiCache, CacheType, initCache } from '../abi-cache'
 import {
   bridge,
   bridgeSwap,
@@ -56,8 +55,8 @@ const validateAndExtractSwapData = (
 let cache: AbiCache
 
 describe('Acceptance tests', () => {
-  beforeAll(() => {
-    cache = initCache(CacheType.MEMORY)
+  beforeAll(async () => {
+    cache = await initCache(CacheType.MEMORY)
   })
 
   it('should parse a swap transfer', () => {

src/parser/parser.test.ts

@@ -1,7 +1,6 @@
 import { FunctionFragment } from 'ethers'
 
-import { AbiCache } from '../abi-cache/abi-cache'
-import { CacheType, initCache } from '../abi-cache/cache'
+import { AbiCache, CacheType, initCache } from '../abi-cache'
 
 import { parseCallData } from './calldata-parsers/parse-call-data'
 
@@ -15,8 +14,8 @@ const wrappedCallFunctionFragment: FunctionFragment = FunctionFragment.from(
 let cache: AbiCache
 
 describe('parseCallData', () => {
-  beforeAll(() => {
-    cache = initCache(CacheType.MEMORY)
+  beforeAll(async () => {
+    cache = await initCache(CacheType.MEMORY)
   })
 
   afterEach(() => {