TW-1406: [EVM] balances loading (#162)

* added endpoints

* rm commented imports

* refactoring according to comments

* separate router for evm endpoints

Author: lendihop

package.json

@@ -6,6 +6,7 @@
   "author": "Inokentii Mazhara <[email protected]>",
   "license": "MIT",
   "dependencies": {
+    "@covalenthq/client-sdk": "^1.0.2",
     "@ethersproject/address": "^5.7.0",
     "@ethersproject/hash": "^5.7.0",
     "@ethersproject/strings": "^5.7.0",
@@ -16,6 +17,7 @@
     "@taquito/tzip12": "14.0.0",
     "@taquito/tzip16": "14.0.0",
     "@taquito/utils": "14.0.0",
+    "async-retry": "^1.3.3",
     "axios": "^0.27.2",
     "bignumber.js": "^9.1.0",
     "body-parser": "^1.20.2",
@@ -49,6 +51,7 @@
     "db-migration": "cd migrations/notifications && npx ts-node index.ts"
   },
   "devDependencies": {
+    "@types/async-retry": "^1.4.8",
     "@types/body-parser": "^1.19.2",
     "@types/express": "^4.17.17",
     "@types/express-jwt": "^7.4.2",

src/config.ts

@@ -12,7 +12,8 @@ export const EnvVars = {
   THREE_ROUTE_API_AUTH_TOKEN: getEnv('THREE_ROUTE_API_AUTH_TOKEN'),
   REDIS_URL: getEnv('REDIS_URL'),
   ADMIN_USERNAME: getEnv('ADMIN_USERNAME'),
-  ADMIN_PASSWORD: getEnv('ADMIN_PASSWORD')
+  ADMIN_PASSWORD: getEnv('ADMIN_PASSWORD'),
+  COVALENT_API_KEY: getEnv('COVALENT_API_KEY')
 };
 
 for (const name in EnvVars) {

src/index.ts

@@ -20,6 +20,7 @@ import { getNotifications } from './notifications/utils/get-notifications.util';
 import { getParsedContent } from './notifications/utils/get-parsed-content.util';
 import { getPlatforms } from './notifications/utils/get-platforms.util';
 import { redisClient } from './redis';
+import { evmRouter } from './routers/evm';
 import { adRulesRouter } from './routers/slise-ad-rules';
 import { getABData } from './utils/ab-test';
 import { cancelAliceBobOrder } from './utils/alice-bob/cancel-alice-bob-order';
@@ -334,6 +335,8 @@ app.get('/api/advertising-info', (_req, res) => {
 
 app.use('/api/slise-ad-rules', adRulesRouter);
 
+app.use('/api/evm', evmRouter);
+
 app.post('/api/magic-square-quest/start', async (req, res) => {
   try {
     await startMagicSquareQuest(req.body);

src/routers/evm/covalent.ts

@@ -0,0 +1,68 @@
+import { ChainID, CovalentClient } from '@covalenthq/client-sdk';
+import retry from 'async-retry';
+
+import { EnvVars } from '../../config';
+import { CodedError } from '../../utils/errors';
+
+const client = new CovalentClient(EnvVars.COVALENT_API_KEY, { enableRetry: false, threadCount: 10 });
+
+const RETRY_OPTIONS = { maxRetryTime: 30_000 };
+
+export const getEvmBalances = async (walletAddress: string, chainId: string) =>
+  await retry(
+    async () =>
+      client.BalanceService.getTokenBalancesForWalletAddress(Number(chainId) as ChainID, walletAddress, {
+        nft: true,
+        noNftAssetMetadata: true,
+        quoteCurrency: 'USD',
+        noSpam: false
+      }).then(({ data, error, error_message, error_code }) => {
+        if (error) {
+          throw new CodedError(Number(error_code) || 500, error_message);
+        }
+
+        return data;
+      }),
+    RETRY_OPTIONS
+  );
+
+export const getEvmTokensMetadata = async (walletAddress: string, chainId: string) =>
+  await retry(
+    async () =>
+      client.BalanceService.getTokenBalancesForWalletAddress(Number(chainId) as ChainID, walletAddress, {
+        nft: false,
+        quoteCurrency: 'USD',
+        noSpam: false
+      }).then(({ data, error, error_message, error_code }) => {
+        if (error) {
+          throw new CodedError(Number(error_code) || 500, error_message);
+        }
+
+        return data;
+      }),
+    RETRY_OPTIONS
+  );
+
+const CHAIN_IDS_WITHOUT_CACHE_SUPPORT = [10, 11155420, 43114, 43113];
+
+export const getEvmCollectiblesMetadata = async (walletAddress: string, chainId: string) => {
+  const withUncached = CHAIN_IDS_WITHOUT_CACHE_SUPPORT.includes(Number(chainId));
+
+  return await retry(
+    async () =>
+      client.NftService.getNftsForAddress(Number(chainId) as ChainID, walletAddress, {
+        withUncached,
+        noSpam: false
+      }).then(({ data, error, error_message, error_code }) => {
+        if (error) {
+          throw new CodedError(Number(error_code) || 500, error_message);
+        }
+
+        return data;
+      }),
+    RETRY_OPTIONS
+  );
+};
+
+export const getStringifiedResponse = (response: any) =>
+  JSON.stringify(response, (_, value) => (typeof value === 'bigint' ? value.toString() : value));

src/routers/evm/index.ts

@@ -0,0 +1,44 @@
+import { Router } from 'express';
+
+import { withCodedExceptionHandler, withEvmQueryValidation } from '../../utils/express-helpers';
+import { getEvmBalances, getEvmCollectiblesMetadata, getEvmTokensMetadata, getStringifiedResponse } from './covalent';
+
+export const evmRouter = Router();
+
+evmRouter
+  .get(
+    '/balances',
+    withCodedExceptionHandler(
+      withEvmQueryValidation(async (_1, res, _2, evmQueryParams) => {
+        const { walletAddress, chainId } = evmQueryParams;
+
+        const data = await getEvmBalances(walletAddress, chainId);
+
+        res.status(200).send(getStringifiedResponse(data));
+      })
+    )
+  )
+  .get(
+    '/tokens-metadata',
+    withCodedExceptionHandler(
+      withEvmQueryValidation(async (_1, res, _2, evmQueryParams) => {
+        const { walletAddress, chainId } = evmQueryParams;
+
+        const data = await getEvmTokensMetadata(walletAddress, chainId);
+
+        res.status(200).send(getStringifiedResponse(data));
+      })
+    )
+  )
+  .get(
+    '/collectibles-metadata',
+    withCodedExceptionHandler(
+      withEvmQueryValidation(async (_1, res, _2, evmQueryParams) => {
+        const { walletAddress, chainId } = evmQueryParams;
+
+        const data = await getEvmCollectiblesMetadata(walletAddress, chainId);
+
+        res.status(200).send(getStringifiedResponse(data));
+      })
+    )
+  );

src/utils/errors.ts

@@ -8,7 +8,7 @@ interface CodedErrorForResponse {
 type StatusCodeNumber = (typeof StatusCodes)[keyof typeof StatusCodes];
 
 export class CodedError extends Error {
-  constructor(public code: StatusCodeNumber, message: string, public errorCode?: string) {
+  constructor(public code: StatusCodeNumber | number, message: string, public errorCode?: string) {
     super(message);
   }
 

src/utils/express-helpers.ts

@@ -2,7 +2,9 @@ import { NextFunction, Request, RequestHandler, Response, Router } from 'express
 import { ArraySchema as IArraySchema, ObjectSchema as IObjectSchema, Schema, ValidationError } from 'yup';
 
 import { basicAuth } from '../middlewares/basic-auth.middleware';
+import { CodedError } from './errors';
 import logger from './logger';
+import { evmQueryParamsSchema } from './schemas';
 
 interface ObjectStorageMethods<V> {
   getByKey: (key: string) => Promise<V>;
@@ -33,6 +35,36 @@ export const withBodyValidation =
     return handler(req, res, next);
   };
 
+interface EvmQueryParams {
+  walletAddress: string;
+  chainId: string;
+}
+
+type TypedEvmQueryRequestHandler = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+  evmQueryParams: EvmQueryParams
+) => void;
+
+export const withEvmQueryValidation =
+  (handler: TypedEvmQueryRequestHandler): RequestHandler =>
+  async (req, res, next) => {
+    let evmQueryParams: EvmQueryParams;
+
+    try {
+      evmQueryParams = await evmQueryParamsSchema.validate(req.query);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        return res.status(400).send({ error: error.message });
+      }
+
+      throw error;
+    }
+
+    return handler(req, res, next, evmQueryParams);
+  };
+
 export const withExceptionHandler =
   (handler: RequestHandler): RequestHandler =>
   async (req, res, next) => {
@@ -44,6 +76,22 @@ export const withExceptionHandler =
     }
   };
 
+export const withCodedExceptionHandler =
+  (handler: RequestHandler): RequestHandler =>
+  async (req, res, next) => {
+    try {
+      await handler(req, res, next);
+    } catch (error: any) {
+      logger.error(error);
+
+      if (error instanceof CodedError) {
+        res.status(error.code).send(error.buildResponse());
+      } else {
+        res.status(500).send({ message: error?.message });
+      }
+    }
+  };
+
 interface ObjectStorageMethodsEntrypointsConfig<StoredValue, ObjectResponse, ValueResponse> {
   path: string;
   methods: ObjectStorageMethods<StoredValue>;

src/utils/schemas.ts

@@ -108,6 +108,11 @@ const adStylesOverridesSchema = objectSchema().shape({
   style: styleSchema.clone().required()
 });
 
+export const evmQueryParamsSchema = objectSchema().shape({
+  walletAddress: nonEmptyStringSchema.clone().required('walletAddress is undefined'),
+  chainId: nonEmptyStringSchema.clone().required('chainId is undefined')
+});
+
 const adPlacesRulesSchema = arraySchema()
   .of(
     objectSchema()