@sabaaa1/common 0.0.1

package/src/API/kycCalls.ts

@@ -0,0 +1,81 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { getServerURL } from './getServerURL';
+import { KycVerificationResult, Passports, VERIFICATION_TYPE } from '../types/kyc.types';
+import { SignatureData } from '../types/crypto.types';
+import { httpClient } from '../data-structures/tor';
+
+interface IGetKycStatus {
+  verificationResult: KycVerificationResult;
+  passportIds?: Passports[];
+}
+
+export async function getUserKycStatus(chainId: number, ethereumAddress: string): Promise<IGetKycStatus> {
+  return httpClient.post<IGetKycStatus>(`${getServerURL(chainId)}${API_CONFIG.ROUTES.checkKycStatus}`, {
+    ethereumAddress,
+  });
+}
+
+// to send verification code on email through server
+export async function setAiPriseVerificationUrl(
+  chainId: number,
+  ethereumAddress: string,
+  verificationSessionId: string,
+  verificationType: VERIFICATION_TYPE,
+) {
+  return httpClient.post(`${getServerURL(chainId)}${API_CONFIG.ROUTES.startUserVerification}`, {
+    ethereumAddress,
+    verificationSessionId,
+    verificationType,
+  });
+}
+
+interface AccessTokenSignatureResponse {
+  signatureData: SignatureData;
+}
+
+export async function getAccessTokenSignature(
+  chainId: number,
+  ethereumAddress: string,
+  accessKey: string,
+): Promise<AccessTokenSignatureResponse> {
+  return httpClient.post(`${getServerURL(chainId)}${API_CONFIG.ROUTES.getUserSignature}`, {
+    ethereumAddress,
+    accessKey,
+  });
+}
+
+interface ReclaimVerificationRequestResponse {
+  reclaimProofRequestConfig: string;
+  message?: string;
+}
+
+export async function getReclaimVerificationRequest(
+  chainId: number,
+  providerId: string,
+  ethereumAddress: string,
+  userSignature: string,
+  withSignature: boolean,
+): Promise<ReclaimVerificationRequestResponse> {
+  return httpClient.post(`${getServerURL(chainId)}${API_CONFIG.ROUTES.startReclaimVerification}`, {
+    ethereumAddress,
+    providerId,
+    userSignature,
+    withSignature,
+  });
+}
+
+export const getZkMeAccessToken = async (chainId: number) => {
+  return (await httpClient.get(`${getServerURL(chainId)}${API_CONFIG.ROUTES.zkMeAccessToken}`)).accessToken;
+};
+
+type IUserHasKyc = {
+  updated: boolean;
+};
+
+export const userHasKyc = async (chainId: number, ethereumAddress: string, hasKyc: boolean) => {
+  const response = await httpClient.post<IUserHasKyc>(`${getServerURL(chainId)}${API_CONFIG.ROUTES.userHasKyc}`, {
+    ethereumAddress,
+    hasKyc,
+  });
+  return response;
+};

package/src/API/leaderboardCalls.ts

@@ -0,0 +1,32 @@
+import { DATA_SERVER_URL } from './getServerURL';
+import { DATA_SERVER_CONFIG } from '../constants/server.constants';
+import { BrotherhoodWeeklyAnalyticLeaderboardEntry, UserWeeklyAnalyticLeaderboardEntry } from '../types';
+import { httpClient } from '../data-structures/tor';
+
+interface GetUserCurrentLeaderboardProps {
+  ethereumAddress: string;
+}
+
+interface GetUserCurrentLeaderboardRes {
+  message: string;
+  sortedUsers: UserWeeklyAnalyticLeaderboardEntry[];
+}
+
+export const getUserCurrentLeaderboard = async ({
+  ethereumAddress,
+}: GetUserCurrentLeaderboardProps): Promise<GetUserCurrentLeaderboardRes> => {
+  return httpClient.get<GetUserCurrentLeaderboardRes>(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getUserCurrentLeaderboard}`,
+    {
+      params: { ethereumAddress },
+    },
+  );
+};
+
+interface GetBrotherhoodLeaderboardRes {
+  analytics: BrotherhoodWeeklyAnalyticLeaderboardEntry[];
+}
+
+export const getBrotherhoodsLeaderboard = async (): Promise<GetBrotherhoodLeaderboardRes> => {
+  return httpClient.get(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getBrotherhoodsLeaderboard}`);
+};

package/src/API/mysteryBoxesCalls.ts

@@ -0,0 +1,141 @@
+import { Address, MerchOrder, MysteryBoxItem, MysteryBoxReward, Rank } from '../types';
+import { DATA_SERVER_CONFIG } from '../constants/server.constants';
+import { getDataServerURL } from './getServerURL';
+import { httpClient } from '../data-structures/tor';
+import { getSignatureHeader } from '../functions/utils/get-signature-header';
+
+interface OpenMysteryBoxRes {
+  message: string;
+  reward?: MysteryBoxItem;
+  rewardsHistory?: MysteryBoxReward[];
+  paid: number;
+}
+
+interface OpenMysteryBoxProps {
+  ethereumAddress: string;
+  rank: Rank;
+  signature: string;
+  proxyAddress: string;
+}
+
+export const openMysteryBox = async ({
+  ethereumAddress,
+  rank,
+  signature,
+  proxyAddress,
+}: OpenMysteryBoxProps): Promise<OpenMysteryBoxRes> => {
+  const data = await httpClient.post(
+    `${getDataServerURL()}${DATA_SERVER_CONFIG.openMysteryBox}`,
+    {
+      ethereumAddress,
+      rank,
+      proxyAddress,
+    },
+    getSignatureHeader(signature),
+  );
+  return data;
+};
+
+interface HistoryListRes {
+  rewardsHistory: MysteryBoxReward[];
+}
+
+interface HistoryListProps {
+  ethereumAddress: string;
+}
+
+export const getMysteryBoxesHistory = async ({ ethereumAddress }: HistoryListProps): Promise<HistoryListRes> => {
+  const data = await httpClient.get(
+    `${getDataServerURL()}${DATA_SERVER_CONFIG.getMysteryBoxesHistory(ethereumAddress)}`,
+  );
+
+  return data;
+};
+
+interface CreationOrUpdateMerchAddressProps {
+  ethereumAddress: string;
+  address: Address;
+}
+
+interface CreateOrUpdateMerchAddressRes {
+  message: string;
+  address: Address;
+}
+
+export const createOrUpdateMerchAddress = async ({
+  ethereumAddress,
+  address,
+}: CreationOrUpdateMerchAddressProps): Promise<CreateOrUpdateMerchAddressRes> => {
+  const data = await httpClient.post(`${getDataServerURL()}${DATA_SERVER_CONFIG.createOrUpdateMerchAddress}`, {
+    ethereumAddress,
+    address,
+  });
+
+  return data;
+};
+
+interface ClaimMerchItemsRes {
+  message: string;
+  orders?: MerchOrder[];
+  rewardsHistory?: MysteryBoxReward[];
+}
+interface ClaimMerchItemsProps {
+  ethereumAddress: string;
+  merchId: number;
+}
+
+export const claimMerchItem = async ({
+  ethereumAddress,
+  merchId,
+}: ClaimMerchItemsProps): Promise<ClaimMerchItemsRes> => {
+  const data = await httpClient.post(`${getDataServerURL()}${DATA_SERVER_CONFIG.claimMerchItem}`, {
+    ethereumAddress,
+    merchId,
+  });
+
+  return data;
+};
+
+interface GetMerchOrdersRes {
+  orders: MerchOrder[];
+}
+
+interface GetMerchOrdersProps {
+  ethereumAddress: string;
+}
+
+export const getMerchOrders = async ({ ethereumAddress }: GetMerchOrdersProps): Promise<GetMerchOrdersRes> => {
+  const data = await httpClient.get(`${getDataServerURL()}${DATA_SERVER_CONFIG.getMerchOrders(ethereumAddress)}`);
+
+  return data;
+};
+
+interface GetCurrentDayBoxPrizeCountsRes {
+  currentDayBoxCounts: Record<Rank, number>;
+}
+
+export const getCurrentDayBoxPrizeCounts = async (): Promise<GetCurrentDayBoxPrizeCountsRes> => {
+  const data = await httpClient.get(`${getDataServerURL()}${DATA_SERVER_CONFIG.getCurrentDayBoxPrizeCounts}`);
+
+  return data;
+};
+
+interface GetCurrentAuctionsInfoRes {
+  purchasedRanks: Record<Rank, boolean>;
+}
+
+export const getCurrentAuctionsInfo = async (): Promise<GetCurrentAuctionsInfoRes> => {
+  const data = await httpClient.get(`${getDataServerURL()}${DATA_SERVER_CONFIG.getCurrentAuctionsInfo}`);
+
+  return data;
+};
+
+interface GetServerUtcRes {
+  utc: number;
+}
+
+export const getServerUtc = async (): Promise<GetServerUtcRes> => {
+  const data = await httpClient.get(`${getDataServerURL()}${DATA_SERVER_CONFIG.getServerUtc}`);
+
+  return data;
+};

package/src/API/passwordCalls.ts

@@ -0,0 +1,34 @@
+import axios from 'axios';
+import { API_CONFIG } from '../constants/server.constants';
+import { getServerURL } from './getServerURL';
+
+type OptionalUserPassword = {
+  passwordHash: string | null;
+};
+
+type UserPassword = {
+  passwordHash: string;
+};
+
+export const userHasPassword = async (chainId: number, ethereumAddress: string): Promise<OptionalUserPassword> => {
+  const response = (
+    await axios.get<OptionalUserPassword>(
+      `${getServerURL(chainId)}${API_CONFIG.ROUTES.userHasPassword(ethereumAddress)}`,
+    )
+  ).data;
+  return response;
+};
+
+export const userRegisterPassword = async (
+  chainId: number,
+  ethereumAddress: string,
+  passwordHash: string,
+): Promise<UserPassword> => {
+  const response = (
+    await axios.post<UserPassword>(`${getServerURL(chainId)}${API_CONFIG.ROUTES.userRegisterPassword}`, {
+      ethereumAddress,
+      passwordHash,
+    })
+  ).data;
+  return response;
+};

package/src/API/proxyAccountsCalls.ts

@@ -0,0 +1,40 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { getServerURL } from './getServerURL';
+import type { SubAccountLight } from '../types/proxy.types';
+import { UserKeys } from '../data-structures/crypto-keys';
+import { ethers } from 'ethers';
+import { hashEthereumAddress } from '../functions/utils/addresses';
+import { httpClient } from '../data-structures/tor';
+
+const generateSecureProxyKey = (ethereumAddress: string, userKeys: UserKeys): string => {
+  const shieldedPrivateKey = userKeys.getShieldedPrivateKey();
+
+  const combinedString = `HinkalProxyAccounts|${ethereumAddress.toLowerCase()}|${shieldedPrivateKey}`;
+
+  // Use keccak256 for consistent hashing
+  return ethers.utils.keccak256(ethers.utils.toUtf8Bytes(combinedString));
+};
+
+export const getProxyAccounts = async (chainId: number, ethereumAddress: string, userKeys: UserKeys) => {
+  const secureKey = generateSecureProxyKey(ethereumAddress, userKeys);
+  const response = await httpClient.get<SubAccountLight[]>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.getProxyAccounts(secureKey)}`,
+  );
+  return response;
+};
+
+export const updateProxyAccounts = async (
+  chainId: number,
+  ethereumAddress: string,
+  userKeys: UserKeys,
+  proxyAccounts: SubAccountLight[],
+) => {
+  const secureKey = generateSecureProxyKey(ethereumAddress, userKeys);
+  const hashedEthereumAddress = hashEthereumAddress(ethereumAddress);
+  const response = await httpClient.post(`${getServerURL(chainId)}${API_CONFIG.ROUTES.updateProxyAccounts}`, {
+    secureKey,
+    hashedEthereumAddress,
+    proxyAccounts,
+  });
+  return response;
+};

package/src/API/referralsCalls.ts

@@ -0,0 +1,52 @@
+import { DATA_SERVER_URL } from './getServerURL';
+import { DATA_SERVER_CONFIG } from '../constants/server.constants';
+import { Referral } from '../types';
+import { httpClient } from '../data-structures/tor';
+
+interface GetCurrentUserReferralProps {
+  ethereumAddress: string;
+}
+
+interface GetCurrentUserReferralRes {
+  referral: Referral | undefined;
+}
+
+export const getCurrentUserReferral = async ({
+  ethereumAddress,
+}: GetCurrentUserReferralProps): Promise<GetCurrentUserReferralRes> => {
+  return httpClient.get(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getCurrentUserReferral}`, {
+    params: { ethereumAddress },
+  });
+};
+
+interface SubmitReferralCodeProps {
+  referralCode: string;
+  ethereumAddress: string;
+}
+
+export interface SubmitReferralCodeRes {
+  message: string;
+  success: boolean;
+}
+
+export const submitReferralCode = async ({
+  referralCode,
+  ethereumAddress,
+}: SubmitReferralCodeProps): Promise<SubmitReferralCodeRes> => {
+  return httpClient.post(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.submitReferralCode}`, {
+    referralCode,
+    ethereumAddress,
+  });
+};
+
+interface GetCurrentUserAppliedReferralCodeRes {
+  appliedReferralCode: string | undefined;
+}
+
+export const getCurrentUserAppliedReferralCode = async (
+  ethereumAddress: string,
+): Promise<GetCurrentUserAppliedReferralCodeRes> => {
+  return httpClient.get(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getCurrentUserAppliedReferralCode}`, {
+    params: { ethereumAddress },
+  });
+};

package/src/API/relayCalls.ts

@@ -0,0 +1,14 @@
+import { getRelayerURL } from './getRelayerURL';
+import { RELAYER_CONFIG } from '../constants/server.constants';
+import { httpClient } from '../data-structures/tor';
+
+interface IGetIdleRelay {
+  relay: string | undefined;
+}
+
+export const getIdleRelay = async (chainId: number, markAsPending = false): Promise<IGetIdleRelay> => {
+  const response = await httpClient.get<IGetIdleRelay>(
+    `${getRelayerURL(chainId)}${RELAYER_CONFIG.getIdleRelay}?markAsPending=${markAsPending}`,
+  );
+  return response;
+};

package/src/API/restoreSnapshots.ts

@@ -0,0 +1,7 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { getServerURL } from './getServerURL';
+import { httpClient } from '../data-structures/tor';
+
+export async function restoreSnapshots(chainId: number) {
+  return httpClient.post(`${getServerURL(chainId)}${API_CONFIG.ROUTES.restoreSnapshots}`);
+}

package/src/API/rewardsUserCalls.ts

@@ -0,0 +1,124 @@
+import { DATA_SERVER_URL } from './getServerURL';
+import { DATA_SERVER_CONFIG } from '../constants/server.constants';
+import { AchievementProgressItem, RewardsUser, SwapStreakClient, TaskProgress } from '../types';
+import { httpClient } from '../data-structures/tor';
+import { getSignatureHeader } from '../functions/utils/get-signature-header';
+
+interface ConnectRewardsUserRes {
+  message: string;
+  user: RewardsUser;
+  isFirstTimeUser: boolean;
+  signature: string;
+}
+
+export const connectRewardsUser = async (
+  ethereumAddress: string,
+  signature: string,
+  firstProxyAddress: string,
+): Promise<ConnectRewardsUserRes> => {
+  const data = await httpClient.post(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.connectRewardsUser}`,
+    {
+      ethereumAddress,
+      proxyAddress: firstProxyAddress,
+    },
+    getSignatureHeader(signature),
+  );
+  return data;
+};
+
+interface InputDataTypes {
+  ethereumAddress: string;
+  signature: string;
+  username?: string;
+  profileImage?: string;
+  proxyAddress?: string;
+}
+
+interface UpdateRewardsUserRes {
+  message: string;
+  user: RewardsUser;
+}
+
+export const updateRewardsUser = async (inputData: InputDataTypes): Promise<UpdateRewardsUserRes> => {
+  const data = await httpClient.patch(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.updateRewardsUser}`,
+    inputData,
+    getSignatureHeader(inputData.signature),
+  );
+
+  return data;
+};
+
+interface GetSwapStreakRes {
+  message: string;
+  swapStreak: SwapStreakClient;
+}
+
+export const getSwapStreak = async (ethereumAddress: string): Promise<GetSwapStreakRes> => {
+  const data = await httpClient.get<GetSwapStreakRes>(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getSwapStreak}`, {
+    params: { ethereumAddress },
+  });
+
+  return data;
+};
+
+interface GetTasksProgressRes {
+  success: boolean;
+  userTasks: TaskProgress[];
+  userAchievements: AchievementProgressItem[];
+  brotherhoodTasks: TaskProgress[];
+  completedTasks: string[];
+  brotherhoodCompletedTasks: string[];
+  pointsToShowInCongratsPopup: number;
+}
+
+export const getTasksProgress = async (ethereumAddress: string): Promise<GetTasksProgressRes> => {
+  const data = await httpClient.get<GetTasksProgressRes>(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getTasksProgress(ethereumAddress)}`,
+  );
+
+  return data;
+};
+
+interface DisconnectSocialNetworkRes {
+  message: string;
+  user: RewardsUser;
+}
+
+interface DisconnectSocialNetworkProps {
+  ethereumAddress: string;
+  socialWebsiteId: string;
+  signature: string;
+  proxyAddress: string;
+}
+
+export const disconnectSocialNetwork = async ({
+  ethereumAddress,
+  socialWebsiteId,
+  signature,
+  proxyAddress,
+}: DisconnectSocialNetworkProps): Promise<DisconnectSocialNetworkRes> => {
+  const data = await httpClient.patch<DisconnectSocialNetworkRes>(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.disconnectSocialNetwork}`,
+    {
+      ethereumAddress,
+      socialWebsiteId,
+      proxyAddress,
+    },
+    getSignatureHeader(signature),
+  );
+
+  return data;
+};
+
+interface GetNftMultiplierRes {
+  nftMultiplier: number;
+}
+
+export const getNftMultiplier = async (ethereumAddress: string): Promise<GetNftMultiplierRes> => {
+  const data = await httpClient.get<GetNftMultiplierRes>(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getNftMultiplier(ethereumAddress)}`,
+  );
+  return data;
+};

package/src/API/send-telegram-callback.ts

@@ -0,0 +1,17 @@
+import { DATA_SERVER_CONFIG } from '../constants/server.constants';
+import { DATA_SERVER_URL } from './getServerURL';
+import { TelegramUser } from '../types';
+import { httpClient } from '../data-structures/tor';
+
+interface TelegramCallbackProps {
+  ethereumAddress: string;
+  telegramUser: TelegramUser;
+}
+
+export const sendTelegramCallback = async ({ ethereumAddress, telegramUser }: TelegramCallbackProps) => {
+  const data = await httpClient.post(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getTelegramCallback}`, {
+    ethereumAddress,
+    telegramUser,
+  });
+  return data;
+};

package/src/API/simulate-batch-tx.ts

@@ -0,0 +1,19 @@
+import { TransactionSimulatorMinimalResult } from '../types/TransactionSimulator.types';
+import { getServerURL } from './getServerURL';
+import { API_CONFIG } from '../constants/server.constants';
+import { WCTransactionParameters } from '../types';
+import { httpClient } from '../data-structures/tor';
+
+export const simulateBatchTx = async (
+  chainId: number,
+  batchCalls: WCTransactionParameters[],
+): Promise<TransactionSimulatorMinimalResult<string>> => {
+  const response = await httpClient.post<TransactionSimulatorMinimalResult<string>>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.simulateBatchTx}`,
+    {
+      batchCalls,
+    },
+  );
+
+  return response;
+};

package/src/API/tenderly.api.ts

@@ -0,0 +1,96 @@
+import type {
+  RpcSimulateResult,
+  RpcSimulateTransactionBody,
+  RpcSimulateTransactionResponse,
+  RpcTransactionParams,
+  SimulateTxBody,
+  SimulateTxResponse,
+} from '../types/tenderly.api.types';
+import { chainIds } from '../constants/chains.constants';
+import { httpClient } from '../data-structures/tor';
+
+const TENDERLY_API_KEY = '7o1iPUgCIjLI0rSxj2yuz9-Z3052uUc4';
+
+const accountSlug = 'hinkal-org';
+const projectSlug = 'project';
+
+const baseUrl = `https://api.tenderly.co/api/v1/account/${accountSlug}/project/${projectSlug}`;
+
+const HEADERS = { 'X-Access-Key': TENDERLY_API_KEY };
+
+// SIMULATE TRANSACTION ON ACTUAL NETWORK
+export const simulateTx = async (simulateTxBody: SimulateTxBody): Promise<SimulateTxResponse> => {
+  const response = await httpClient.post<SimulateTxResponse>(
+    `${baseUrl}/simulate`,
+    { ...simulateTxBody },
+    {
+      headers: HEADERS,
+    },
+  );
+  return response;
+};
+
+// TENDERLY RPC SIMULATE TRANSACTION
+export const tenderlyRpcLinks = {
+  [chainIds.optimism]: 'https://optimism.gateway.tenderly.co/2A3r4RCMoAZVmQOpNqRO29',
+  [chainIds.base]: 'https://base.gateway.tenderly.co/73UtIBn1YiCyhqRJuKTkWl',
+  [chainIds.ethMainnet]: 'https://mainnet.gateway.tenderly.co/SW3mROrzKEQYSq3RkStJ7',
+  [chainIds.avalanche]: 'https://avalanche.gateway.tenderly.co/2YdoJTNLCUHfzwvqIUVgwZ',
+  [chainIds.arbMainnet]: 'https://arbitrum.gateway.tenderly.co/4dUF2wEnsmvFw9fqLpoLga',
+  [chainIds.polygon]: 'https://polygon.gateway.tenderly.co/32hCaUScB41nXgyzCmeDVu',
+  // Arc Testnet is not supported by Tenderly
+};
+
+export const rpcSimulateTransaction = async (
+  chainId: number,
+  simulateTxBody: RpcSimulateTransactionBody,
+): Promise<RpcSimulateTransactionResponse> => {
+  const response = await httpClient.post<RpcSimulateTransactionResponse>(
+    tenderlyRpcLinks[chainId],
+    { jsonrpc: '2.0', id: 0, method: 'tenderly_simulateTransaction', params: simulateTxBody.params },
+    {
+      headers: HEADERS,
+    },
+  );
+  return response;
+};
+
+export const rpcSimulateBundle = async (
+  chainId: number,
+  simulateTxBody: RpcSimulateTransactionBody<RpcTransactionParams[]>,
+): Promise<RpcSimulateTransactionResponse<RpcSimulateResult[]>> => {
+  const response = await httpClient.post(
+    tenderlyRpcLinks[chainId],
+    { jsonrpc: '2.0', id: 0, method: 'tenderly_simulateBundle', params: simulateTxBody.params },
+    { headers: HEADERS },
+  );
+  return response;
+};
+
+export const rpcGetStorageChanges = async (chainId: number, address: string, offset: string) => {
+  const response = await httpClient.post<any>(
+    tenderlyRpcLinks[chainId],
+    {
+      jsonrpc: '2.0',
+      id: 0,
+      method: 'tenderly_getStorageChanges',
+      params: [
+        {
+          address,
+          offset,
+        },
+      ],
+    },
+    {
+      headers: HEADERS,
+    },
+  );
+  return response;
+};
+
+export const WALLET_API = {
+  rpcGetStorageChanges,
+  rpcSimulateTransaction,
+  rpcSimulateBundle,
+  simulateTx,
+};

package/src/API/token-calls.ts

@@ -0,0 +1,19 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { getServerURL } from './getServerURL';
+import { ERC20Token } from '../types';
+import { httpClient } from '../data-structures/tor';
+
+export const tokensInfoCall = async (
+  chainId: number,
+  tokenAddresses: string[],
+  waitForOffsetUpdate = false,
+): Promise<(ERC20Token | undefined)[]> => {
+  const response = await httpClient.post<(ERC20Token | undefined)[]>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.getTokensInfo}`,
+    {
+      tokenAddresses,
+      waitForOffsetUpdate,
+    },
+  );
+  return response;
+};