fix(app): add error handling for JSON parsing

apps/app/src/components/app/Address/AccountOverviewActions.tsx

@@ -2,7 +2,7 @@
 
 import Big from 'big.js';
 import { useTranslations } from 'next-intl';
-import React, { use, useEffect, useRef, useState } from 'react';
+import React, { use, useEffect, useMemo, useRef, useState } from 'react';
 
 import { useConfig } from '@/hooks/app/useConfig';
 import { dollarFormat, fiatValue, yoctoToNear } from '@/utils/app/libs';
@@ -61,7 +61,6 @@ const AccountOverviewActions = ({
   const statsData = useStatsStore((state) => state.latestStats);
   const tokenData = token?.contracts?.[0];
   const inventoryData = inventory?.inventory;
-  const spamTokens = typeof spam === 'string' ? JSON.parse(spam) : null;
   const { account: accountView } = useAddressRpc();
   const [ft, setFT] = useState<FtInfo>({} as FtInfo);
   const t = useTranslations();
@@ -78,6 +77,17 @@ const AccountOverviewActions = ({
 
   const cacheRef = useRef<BalanceCache>({});
 
+  const spamTokens = useMemo(() => {
+    if (typeof spam === 'string') {
+      try {
+        return JSON.parse(spam);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }, [spam]);
+
   useEffect(() => {
     const cacheKey = `${params?.id}_${rpcUrl}`;
     if (cacheRef.current[cacheKey]) {

apps/app/src/hooks/app/useRpc.ts

@@ -447,8 +447,16 @@ const useRpc = () => {
     if (statusCode === 200) {
       const result = data?.result?.result;
       if (result && (result instanceof Uint8Array || Array.isArray(result))) {
-        const parsed = JSON.parse(Buffer.from(result).toString());
-        return { success: true, data: parsed, statusCode };
+        try {
+          const parsed = JSON.parse(Buffer.from(result).toString());
+          return { success: true, data: parsed, statusCode };
+        } catch {
+          return {
+            success: false,
+            error: data?.result,
+            statusCode,
+          };
+        }
       } else {
         return {
           success: false,

apps/app/src/hooks/app/useSearchHistory.ts

@@ -28,11 +28,15 @@ const useSearchHistory = () => {
     for (const request of keys) {
       const response = await cache.match(request);
       if (response) {
-        const data = await response.json();
-        entries.push({
-          key: request.url,
-          timestamp: data.timestamp || 0,
-        });
+        try {
+          const data = await response.json();
+          entries.push({
+            key: request.url,
+            timestamp: data.timestamp || 0,
+          });
+        } catch {
+          //
+        }
       }
     }
 
@@ -72,8 +76,12 @@ const useSearchHistory = () => {
       const response = await cache.match(request);
 
       if (response) {
-        const data = await response.json();
-        return data.results;
+        try {
+          const data = await response.json();
+          return data.results;
+        } catch {
+          return null;
+        }
       }
     }
 
@@ -90,13 +98,17 @@ const useSearchHistory = () => {
         keys.map(async (request) => {
           const response = await cache.match(request);
           if (response) {
-            const data = await response.json();
-            return {
-              query: data.query,
-              filter: data.filter,
-              results: data.results,
-              timestamp: data.timestamp || 0,
-            };
+            try {
+              const data = await response.json();
+              return {
+                query: data.query,
+                filter: data.filter,
+                results: data.results,
+                timestamp: data.timestamp || 0,
+              };
+            } catch {
+              return null;
+            }
           }
           return null;
         }),

apps/app/src/utils/app/libs.ts

@@ -463,7 +463,11 @@ export const isJson = (string: string) => {
 const strToType = (str: string, type: GuessableTypeString): unknown => {
   switch (type) {
     case 'json':
-      return JSON.parse(str);
+      try {
+        return JSON.parse(str);
+      } catch {
+        return str + '';
+      }
     case 'number':
       return Number(str);
     case 'boolean':

apps/app/src/utils/app/near.ts

@@ -64,8 +64,12 @@ export function encodeArgs(args: object) {
 
 export function decodeArgs(args: string[]) {
   if (!args || typeof args === 'undefined') return {};
-  // @ts-ignore
-  return JSON.parse(Buffer.from(args, 'base64').toString());
+  try {
+    // @ts-ignore
+    return JSON.parse(Buffer.from(args, 'base64').toString());
+  } catch {
+    return {};
+  }
 }
 
 export function tokenAmount(amount: string, decimal: string, format: boolean) {

apps/app/src/utils/libs.ts

@@ -452,16 +452,20 @@ export const isJson = (string: string) => {
 
   try {
     JSON.parse(str);
-    return false;
-  } catch (e) {
+    return true;
+  } catch {
     return false;
   }
 };
 
 const strToType = (str: string, type: GuessableTypeString): unknown => {
   switch (type) {
     case 'json':
-      return JSON.parse(str);
+      try {
+        return JSON.parse(str);
+      } catch {
+        return str + '';
+      }
     case 'number':
       return Number(str);
     case 'boolean':
@@ -681,21 +685,23 @@ export function parseNestedJSON(obj: any): any {
 export const parseEventJson = (log: string) => {
   if (!log?.startsWith('EVENT_JSON:')) return log;
 
-  const jsonString = log.replace('EVENT_JSON:', '').trim();
+  let jsonString = log.replace('EVENT_JSON:', '').trim();
 
   if (typeof jsonString !== 'string') {
     throw new Error('jsonString is not a valid string');
   }
 
   if (!isValidJson(jsonString)) {
-    const fixedJsonString = jsonString.replace(/\\"/g, '"');
+    jsonString = jsonString.replace(/\\"/g, '"');
 
-    if (isValidJson(fixedJsonString)) {
-      return JSON.parse(fixedJsonString);
-    } else {
+    if (!isValidJson(jsonString)) {
       return null;
     }
   }
 
-  return JSON.parse(jsonString);
+  try {
+    return JSON.parse(jsonString);
+  } catch {
+    return null;
+  }
 };

apps/app/src/utils/near.ts

@@ -75,8 +75,12 @@ export function encodeArgs(args: object) {
 
 export function decodeArgs(args: string[]) {
   if (!args || typeof args === 'undefined') return {};
-  // @ts-ignore
-  return JSON.parse(Buffer.from(args, 'base64')?.toString());
+  try {
+    // @ts-ignore
+    return JSON.parse(Buffer.from(args, 'base64').toString());
+  } catch {
+    return {};
+  }
 }
 
 export function tokenAmount(amount: string, decimal: string, format: boolean) {