feat: Add LRU cache alongside redis

package.json

@@ -15,7 +15,7 @@
     "rimraf": "^5.0.5",
     "tsconfig": "workspace:*",
     "tsup": "^7.2.0",
-    "turbo": "latest"
+    "turbo": "^1.13.4"
   },
   "packageManager": "[email protected]",
   "name": "explorer-kit"

packages/explorerkit-server/package.json

@@ -50,6 +50,7 @@
     "bs58": "^5.0.0",
     "dotenv": "^16.4.5",
     "express": "^4.18.2",
+    "lru-cache": "^10.2.2",
     "prom-client": "^15.1.0",
     "redis": "^4.6.14",
     "vite": "^5.2.13",

packages/explorerkit-server/src/components/decoders/errors.spec.ts

@@ -4,8 +4,24 @@ import { decodeProgramError } from "@/components/decoders/errors";
 import { loadAllIdls } from "@/components/idls";
 
 vi.mock("@/core/shared-dependencies", (loadActual) => {
+  class MultiCacheMock {
+    private data: Record<string, string> = {};
+
+    async get(key: string) {
+      return this.data[key] || null;
+    }
+
+    async multiGet(keys: string[]) {
+      return keys.map((key) => this.data[key] || null);
+    }
+
+    async set(key: string, value: string) {
+      this.data[key] = value;
+    }
+  }
+
   const deps = {
-    cache: new Map(),
+    cache: new MultiCacheMock(),
   };
 
   return {

packages/explorerkit-server/src/components/decoders/errors.ts

@@ -1,4 +1,4 @@
-import { ParserType } from "@solanafm/explorer-kit";
+import { checkIfErrorsParser, ParserType } from "@solanafm/explorer-kit";
 
 import { IdlsMap } from "@/components/idls";
 import { ProgramError } from "@/types";
@@ -18,7 +18,7 @@ export function decodeProgramError(idls: IdlsMap, programError: ProgramError): P
   const hexErrorCode = `0x${programError.errorCode.toString(16)}`;
   const errorParser = parser.createParser(ParserType.ERROR);
 
-  if (!errorParser || !("parseError" in errorParser)) {
+  if (!errorParser || !checkIfErrorsParser(errorParser)) {
     return programError;
   }
 

packages/explorerkit-server/src/components/decoders/instructions.spec.ts

@@ -4,8 +4,24 @@ import { decodeInstruction } from "@/components/decoders/instructions";
 import { loadAllIdls } from "@/components/idls";
 
 vi.mock("@/core/shared-dependencies", (loadActual) => {
+  class MultiCacheMock {
+    private data: Record<string, string> = {};
+
+    async get(key: string) {
+      return this.data[key] || null;
+    }
+
+    async multiGet(keys: string[]) {
+      return keys.map((key) => this.data[key] || null);
+    }
+
+    async set(key: string, value: string) {
+      this.data[key] = value;
+    }
+  }
+
   const deps = {
-    cache: new Map(),
+    cache: new MultiCacheMock(),
   };
 
   return {

packages/explorerkit-server/src/components/decoders/instructions.ts

@@ -1,10 +1,10 @@
-import { ParserType } from "@solanafm/explorer-kit";
+import { checkIfInstructionParser, ParserType } from "@solanafm/explorer-kit";
 import { Buffer } from "buffer";
 
 import { IdlsMap } from "@/components/idls";
 import { Instruction, TopLevelInstruction } from "@/types";
 
-export async function decodeInstruction(idls: IdlsMap, instruction: Instruction): Promise<Instruction> {
+export function decodeInstruction(idls: IdlsMap, instruction: Instruction): Instruction {
   const programId = instruction.programId.toString();
   let parsedInstruction = {
     programId: programId.toString(),
@@ -20,7 +20,7 @@ export async function decodeInstruction(idls: IdlsMap, instruction: Instruction)
   }
   let instructionParser = parser.createParser(ParserType.INSTRUCTION);
 
-  if (!instructionParser || !("parseInstructions" in instructionParser)) {
+  if (!instructionParser || !checkIfInstructionParser(instructionParser)) {
     return parsedInstruction; // Short-circuit without decodedData parser can't be created
   }
 

packages/explorerkit-server/src/components/idls.ts

@@ -9,21 +9,26 @@ const IDL_CACHE_TTL = 3600; // one hour
 
 export async function loadAllIdls(programIds: string[]): Promise<IdlsMap> {
   const idls: IdlsMap = new Map();
+
+  if (programIds.length === 0) {
+    return idls;
+  }
+
   const cache = getSharedDep("cache");
-  const cachedIdls = await Promise.allSettled(programIds.map((id) => cache.get(id)));
+  const cachedIdls = await cache.multiGet(programIds, IDL_CACHE_TTL);
 
   await Promise.allSettled(
     cachedIdls.map(async (res, i) => {
       const programId = programIds[i]!;
 
-      if (res.status === "fulfilled" && res.value) {
-        const idl = deserializeIdl(res.value);
+      if (res) {
+        const idl = deserializeIdl(res);
         idls.set(programId, idl && new SolanaFMParser(idl, programId));
         return;
       }
 
       const idl = await getProgramIdl(programId);
-      void cache.set(programId, serializeIdl(idl), { EX: IDL_CACHE_TTL });
+      void cache.set(programId, serializeIdl(idl), IDL_CACHE_TTL);
       idls.set(programId, idl && new SolanaFMParser(idl, programId));
     })
   );

packages/explorerkit-server/src/core/cache.ts

@@ -1,58 +1,108 @@
+import { LRUCache } from "lru-cache";
 import { Gauge } from "prom-client";
 import { createClient, RedisClientType } from "redis";
 
 import { register } from "@/components/metrics";
 import { config } from "@/core/config";
 import { onTeardown } from "@/utils/teardown";
 
-export async function createCache(): Promise<RedisClientType> {
-  const client = createClient({
-    url: config.REDIS_URL,
-  });
+const LRU_CACHE_MAX_ITEMS_COUNT = 100;
 
-  await client.connect();
+type CacheMetricGauges = {
+  redisHits: Gauge<string>;
+  lruHits: Gauge<string>;
+  misses: Gauge<string>;
+};
 
-  onTeardown(async () => {
-    await client.disconnect();
-  });
+class MultiCache {
+  constructor(
+    private redis: RedisClientType,
+    private lruCache: LRUCache<string, string>,
+    private guages: CacheMetricGauges
+  ) {}
 
-  return instrumentClient(client as RedisClientType);
-}
+  async multiGet(keys: string[], ttlInS: number = 0): Promise<(string | null)[]> {
+    const items: Record<string, string | null> = {};
+    const missingLruKeys: string[] = [];
 
-const instrumentClient = (client: RedisClientType): RedisClientType => {
-  const hitsGauge = new Gauge({
-    name: "cache_hits_total",
-    help: "Total number of cache hits",
-    registers: [register],
-  });
+    for (const key of keys) {
+      const value = this.lruCache.get(key);
 
-  const missesGauge = new Gauge({
-    name: "cache_misses_total",
-    help: "Total number of cache misses",
-    registers: [register],
-  });
-
-  return new Proxy(client, {
-    get(target, prop, receiver) {
-      if (prop === "get") {
-        return async (key: string) => {
-          const value = await target.get(key);
+      if (value) {
+        items[key] = value;
+        this.guages.lruHits.inc();
+      } else {
+        missingLruKeys.push(key);
+      }
+    }
 
-          if (value) {
-            hitsGauge.inc();
-          } else {
-            missesGauge.inc();
-          }
+    if (missingLruKeys.length > 0) {
+      const redisItems = await this.redis.mGet(missingLruKeys);
 
-          return value;
-        };
+      for (const [i, maybeIdl] of redisItems.entries()) {
+        const key = missingLruKeys[i]!;
+        items[key] = maybeIdl;
+        if (maybeIdl) {
+          this.guages.redisHits.inc();
+          this.lruCache.set(key, maybeIdl, {
+            ttl: ttlInS * 1000,
+          });
+        } else {
+          this.guages.misses.inc();
+        }
       }
+    }
 
-      const value = Reflect.get(target, prop, receiver);
+    return keys.map((key) => items[key] ?? null);
+  }
 
-      if (typeof value === "function") {
-        return value.bind(target);
-      }
-    },
+  async set(key: string, value: string, ttlInS: number = 0): Promise<void> {
+    this.lruCache.set(key, value, {
+      ttl: ttlInS * 1000,
+    });
+
+    await this.redis.set(key, value, {
+      EX: ttlInS,
+    });
+  }
+
+  async teardown() {
+    await this.redis.disconnect();
+  }
+}
+
+export async function createCache(): Promise<MultiCache> {
+  const redisClient = createClient({
+    url: config.REDIS_URL,
   });
-};
+  await redisClient.connect();
+
+  const lruCache = new LRUCache<string, string>({
+    max: LRU_CACHE_MAX_ITEMS_COUNT,
+    updateAgeOnGet: true,
+  });
+
+  const multiCache = new MultiCache(redisClient as RedisClientType, lruCache, {
+    redisHits: new Gauge({
+      name: "redis_cache_hits_total",
+      help: "Total number of redis cache hits",
+      registers: [register],
+    }),
+    lruHits: new Gauge({
+      name: "lru_cache_hits_total",
+      help: "Total number of lru-cache hits",
+      registers: [register],
+    }),
+    misses: new Gauge({
+      name: "cache_misses_total",
+      help: "Total number of cache misses",
+      registers: [register],
+    }),
+  });
+
+  onTeardown(async () => {
+    await multiCache.teardown();
+  });
+
+  return multiCache;
+}

packages/explorerkit-server/src/server.test.ts

@@ -4,8 +4,24 @@ import { describe, expect, it, vi } from "vitest";
 import { app } from "@/server";
 
 vi.mock("@/core/shared-dependencies", (loadActual) => {
+  class MultiCacheMock {
+    private data: Record<string, string> = {};
+
+    async get(key: string) {
+      return this.data[key] || null;
+    }
+
+    async multiGet(keys: string[]) {
+      return keys.map((key) => this.data[key] || null);
+    }
+
+    async set(key: string, value: string) {
+      this.data[key] = value;
+    }
+  }
+
   const deps = {
-    cache: new Map(),
+    cache: new MultiCacheMock(),
   };
 
   return {

packages/explorerkit-server/src/server.ts

@@ -1,4 +1,4 @@
-import { AccountParserInterface, ParserType } from "@solanafm/explorer-kit";
+import { checkIfAccountParser, ParserType } from "@solanafm/explorer-kit";
 import bodyParser from "body-parser";
 import express, { Express, Request, Response } from "express";
 import { collectDefaultMetrics } from "prom-client";
@@ -76,7 +76,13 @@ app.post("/decode/accounts", responseDurationMiddleware, async (req: Request, re
       }
 
       // Parse the account
-      let accountParser = parser.createParser(ParserType.ACCOUNT) as AccountParserInterface;
+      const accountParser = parser.createParser(ParserType.ACCOUNT);
+
+      if (!accountParser || !checkIfAccountParser(accountParser)) {
+        decodedAccounts.push({ decodedData: null });
+        continue;
+      }
+
       const decodedData = accountParser.parseAccount(account.data);
       decodedAccounts.push({
         decodedData: decodedData
@@ -96,7 +102,9 @@ const decodeErrorsSchema = z.object({
   errors: z.array(
     z
       .object({
-        programId: z.string(),
+        programId: z.string().refine(isValidBase58, {
+          message: "error.programId is not a valid base58 string",
+        }),
         errorCode: z.coerce.number().nullable().optional(),
       })
       .nullable()
@@ -132,13 +140,17 @@ const decodeInstructionsSchema = z.object({
       .array(
         z.object({
           topLevelInstruction: z.object({
-            programId: z.string(),
+            programId: z.string().refine(isValidBase58, {
+              message: "topLevelInstruction.programId is not a valid base58 string",
+            }),
             encodedData: z.string(),
             accountKeys: z.array(z.string()),
           }),
           flattenedInnerInstructions: z.array(
             z.object({
-              programId: z.string(),
+              programId: z.string().refine(isValidBase58, {
+                message: "flattenedInnerInstructions.programId is not a valid base58 string",
+              }),
               encodedData: z.string(),
               accountKeys: z.array(z.string()),
             })
@@ -174,11 +186,11 @@ app.post("/decode/instructions", responseDurationMiddleware, async (req: Request
 
       for (const instruction of transactionInstructions) {
         // First decode top level ix, then all nested ixs
-        const decodedTopLevelInstruction = await decodeInstruction(idls, instruction.topLevelInstruction);
+        const decodedTopLevelInstruction = decodeInstruction(idls, instruction.topLevelInstruction);
         const decodedInnerInstruction = [];
 
         for (const innerInstruction of instruction.flattenedInnerInstructions) {
-          decodedInnerInstruction.push(await decodeInstruction(idls, innerInstruction));
+          decodedInnerInstruction.push(decodeInstruction(idls, innerInstruction));
         }
 
         decodedTransaction.push({
@@ -191,7 +203,7 @@ app.post("/decode/instructions", responseDurationMiddleware, async (req: Request
 
     return res.status(200).json({ decodedTransactions });
   } catch (e: any) {
-    console.error("failed to decode instructions", e);
+    console.error("failed to decode instructions", e, JSON.stringify(data));
     return res.status(500).json({ error: e.message });
   }
 });

packages/explorerkit-translator/src/parsers/v2/account/token.ts

@@ -87,7 +87,6 @@ export const createShankTokenAccount: (idlItem: IdlItem) => AccountParserInterfa
 
       return null;
     } catch (error) {
-      console.error(error);
       return null;
     }
   };