@sabaaa1/common 0.0.1

package/src/API/API.ts

@@ -0,0 +1,203 @@
+import { getIdleRelay } from './relayCalls';
+import { userHasPassword, userRegisterPassword } from './passwordCalls';
+import { getTokenPrice, getTokenPriceEth, getTokenPrices } from './getTokenPrice';
+import {
+  getAccessTokenSignature,
+  getReclaimVerificationRequest,
+  getUserKycStatus,
+  getZkMeAccessToken,
+  setAiPriseVerificationUrl,
+  userHasKyc,
+} from './kycCalls';
+import { getOdosPriceForToken } from './callOdosAPI';
+import { getTokenApprovalAmountRequest, getTokenSpendsFromOrderMessageRequest } from './ai-calls';
+import { isTxStateless } from './is-tx-stateless';
+import { simulateBatchTx } from './simulate-batch-tx';
+import { tokensInfoCall } from './token-calls';
+import { getTokenData } from './get-token-data';
+import { decryptUtxoEnclaveCall } from './enclaveCalls';
+import { getBridgeProtocols } from './getBridgeProtocols';
+import { getLifiStatus } from './getLifiStatus';
+import { generateAumPoints, generateTradingPoints } from './generate-trading-points';
+import {
+  createBrotherhood,
+  editBrotherhood,
+  getBrotherhood,
+  getBrotherhoodUsers,
+  getCurrentUserBrotherhood,
+  getCurrentUserBrotherhoodUsers,
+  getPublicBrotherhoods,
+  joinBrotherhood,
+  leaveBrotherhood,
+} from './brotherhoodCalls';
+import { getBrotherhoodsLeaderboard, getUserCurrentLeaderboard } from './leaderboardCalls';
+import { getCurrentUserAppliedReferralCode, getCurrentUserReferral, submitReferralCode } from './referralsCalls';
+import {
+  connectRewardsUser,
+  disconnectSocialNetwork,
+  getNftMultiplier,
+  getSwapStreak,
+  getTasksProgress,
+  updateRewardsUser,
+} from './rewardsUserCalls';
+import { getBrotherhoodAnalytics, getUserAnalytics } from './weeklyAnalyticCalls';
+import { sendTelegramCallback } from './send-telegram-callback';
+import { getProxyAccounts, updateProxyAccounts } from './proxyAccountsCalls';
+import {
+  claimMerchItem,
+  createOrUpdateMerchAddress,
+  getCurrentAuctionsInfo,
+  getCurrentDayBoxPrizeCounts,
+  getMerchOrders,
+  getMysteryBoxesHistory,
+  getServerUtc,
+  openMysteryBox,
+} from './mysteryBoxesCalls';
+import { monitor } from './callMonitor';
+
+export type IAPI = {
+  getUserKycStatus: typeof getUserKycStatus;
+  setAiPriseVerificationUrl: typeof setAiPriseVerificationUrl;
+  getAccessTokenSignature: typeof getAccessTokenSignature;
+  getReclaimVerificationRequest: typeof getReclaimVerificationRequest;
+  getZkMeAccessToken: typeof getZkMeAccessToken;
+  getTokenPrice: typeof getTokenPrice;
+  getTokenPriceEth: typeof getTokenPriceEth;
+  getTokenPrices: typeof getTokenPrices;
+  getOdosPriceForToken: typeof getOdosPriceForToken;
+  getIdleRelay: typeof getIdleRelay;
+  userHasPassword: typeof userHasPassword;
+  userRegisterPassword: typeof userRegisterPassword;
+  getTokenApprovalAmountRequest: typeof getTokenApprovalAmountRequest;
+  getTokenSpendsFromOrderMessageRequest: typeof getTokenSpendsFromOrderMessageRequest;
+  isTxStateless: typeof isTxStateless;
+  simulateBatchTx: typeof simulateBatchTx;
+  tokensInfoCall: typeof tokensInfoCall;
+  getTokenData: typeof getTokenData;
+  decryptUtxoEnclaveCall: typeof decryptUtxoEnclaveCall;
+  getBridgeProtocols: typeof getBridgeProtocols;
+  getLifiStatus: typeof getLifiStatus;
+  userHasKyc: typeof userHasKyc;
+  generateTradingPoints: typeof generateTradingPoints;
+  getBrotherhoodUsers: typeof getBrotherhoodUsers;
+  getCurrentUserBrotherhoodUsers: typeof getCurrentUserBrotherhoodUsers;
+  editBrotherhood: typeof editBrotherhood;
+  createBrotherhood: typeof createBrotherhood;
+  getCurrentUserBrotherhood: typeof getCurrentUserBrotherhood;
+  getPublicBrotherhoods: typeof getPublicBrotherhoods;
+  leaveBrotherhood: typeof leaveBrotherhood;
+  joinBrotherhood: typeof joinBrotherhood;
+  getUserAnalytics: typeof getUserAnalytics;
+  connectRewardsUser: typeof connectRewardsUser;
+  getBrotherhood: typeof getBrotherhood;
+  updateRewardsUser: typeof updateRewardsUser;
+  getUserCurrentLeaderboard: typeof getUserCurrentLeaderboard;
+  getBrotherhoodsLeaderboard: typeof getBrotherhoodsLeaderboard;
+  getCurrentUserReferral: typeof getCurrentUserReferral;
+  submitReferralCode: typeof submitReferralCode;
+  getCurrentUserAppliedReferralCode: typeof getCurrentUserAppliedReferralCode;
+  sendTelegramCallback: typeof sendTelegramCallback;
+  generateAumPoints: typeof generateAumPoints;
+  getSwapStreak: typeof getSwapStreak;
+  getBrotherhoodAnalytics: typeof getBrotherhoodAnalytics;
+  getTasksProgress: typeof getTasksProgress;
+  disconnectSocialNetwork: typeof disconnectSocialNetwork;
+  getProxyAccounts: typeof getProxyAccounts;
+  updateProxyAccounts: typeof updateProxyAccounts;
+  openMysteryBox: typeof openMysteryBox;
+  getMysteryBoxesHistory: typeof getMysteryBoxesHistory;
+  createOrUpdateMerchAddress: typeof createOrUpdateMerchAddress;
+  claimMerchItem: typeof claimMerchItem;
+  getMerchOrders: typeof getMerchOrders;
+  getNftMultiplier: typeof getNftMultiplier;
+  getCurrentDayBoxPrizeCounts: typeof getCurrentDayBoxPrizeCounts;
+  getCurrentAuctionsInfo: typeof getCurrentAuctionsInfo;
+  getServerUtc: typeof getServerUtc;
+  monitor: typeof monitor;
+};
+
+export const API: IAPI = {
+  // KYC
+  getUserKycStatus,
+  setAiPriseVerificationUrl,
+  getAccessTokenSignature,
+  getReclaimVerificationRequest,
+  getZkMeAccessToken,
+  userHasKyc,
+  // Prices
+  getTokenPrice,
+  getTokenPriceEth,
+  getTokenPrices,
+  getOdosPriceForToken,
+  // relay
+  getIdleRelay,
+  // password
+  userHasPassword,
+  userRegisterPassword,
+  // points
+  generateTradingPoints,
+  generateAumPoints,
+  // brotherhood
+  getBrotherhoodUsers,
+  getCurrentUserBrotherhoodUsers,
+  getBrotherhood,
+  editBrotherhood,
+  createBrotherhood,
+  getCurrentUserBrotherhood,
+  getPublicBrotherhoods,
+  leaveBrotherhood,
+  joinBrotherhood,
+  // weekly analytics
+  getUserAnalytics,
+  getBrotherhoodAnalytics,
+  // rewards user
+  connectRewardsUser,
+  updateRewardsUser,
+  disconnectSocialNetwork,
+  // leaderboard
+  getUserCurrentLeaderboard,
+  getBrotherhoodsLeaderboard,
+  // referral
+  getCurrentUserReferral,
+  submitReferralCode,
+  getCurrentUserAppliedReferralCode,
+  // AI
+  getTokenApprovalAmountRequest,
+  getTokenSpendsFromOrderMessageRequest,
+  // tenderly
+  isTxStateless,
+  simulateBatchTx,
+  // token calls
+  tokensInfoCall,
+  getTokenData,
+  // enclave
+  decryptUtxoEnclaveCall,
+  // bridge protocols
+  getBridgeProtocols,
+  // lifi
+  getLifiStatus,
+  // callbacks
+  sendTelegramCallback,
+  // tasks
+  getTasksProgress,
+  // swap streak
+  getSwapStreak,
+  // proxy accounts
+  getProxyAccounts,
+  updateProxyAccounts,
+  // mystery boxes
+  openMysteryBox,
+  getMysteryBoxesHistory,
+  createOrUpdateMerchAddress,
+  claimMerchItem,
+  getMerchOrders,
+  getCurrentDayBoxPrizeCounts,
+  // nft multiplier
+  getNftMultiplier,
+  // auction
+  getCurrentAuctionsInfo,
+  // server utc
+  getServerUtc,
+  // hexagate
+  monitor,
+};

package/src/API/admin-calls.ts

@@ -0,0 +1,8 @@
+import { RELAYER_CONFIG } from '../constants/server.constants';
+import { getRelayerURL } from './getRelayerURL';
+import { httpClient } from '../data-structures/tor';
+import { AdminDataType } from '../types/admin.types';
+
+export const emitTxPublicData = (chainId: number, adminData: AdminDataType | undefined) => {
+  return httpClient.post(`${getRelayerURL(chainId)}${RELAYER_CONFIG.emitTxPublicData}`, { adminData });
+};

package/src/API/ai-calls.ts

@@ -0,0 +1,48 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { getServerURL } from './getServerURL';
+import { httpClient } from '../data-structures/tor';
+
+type TokenInfo = {
+  address?: string;
+  symbol?: string;
+  name?: string;
+};
+
+interface GetTokenApprovalAmountsResponse {
+  tokenAmount: string;
+}
+
+export const getTokenApprovalAmountRequest = async (
+  html: string,
+  tokenInfo: TokenInfo,
+  chainId: number,
+): Promise<GetTokenApprovalAmountsResponse> => {
+  return httpClient.post<GetTokenApprovalAmountsResponse>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.getTokenApprovalAmount}`,
+    {
+      html,
+      tokenInfo,
+    },
+  );
+};
+
+interface GetTokenSpendsFromOrderMessageResponse {
+  tokenSpends: {
+    token: string;
+    amount: string;
+  }[];
+}
+
+export const getTokenSpendsFromOrderMessageRequest = async (
+  chainId: number,
+  message: Record<string, unknown>,
+  types: Record<string, unknown>,
+) => {
+  return httpClient.post<GetTokenSpendsFromOrderMessageResponse>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.getTokenSpendsFromOrderMessage}`,
+    {
+      message,
+      types,
+    },
+  );
+};

package/src/API/brotherhoodCalls.ts

@@ -0,0 +1,184 @@
+import { DATA_SERVER_URL } from './getServerURL';
+import { DATA_SERVER_CONFIG } from '../constants/server.constants';
+import {
+  Brotherhood,
+  BrotherhoodUser,
+  BrotherhoodUserWeeklyAnalyticLeaderboardEntry,
+  PublicBrotherhoodWithStats,
+} from '../types';
+import { httpClient } from '../data-structures/tor';
+import { getSignatureHeader } from '../functions/utils/get-signature-header';
+
+interface GetBrotherhoodProps {
+  brotherhoodId: number;
+}
+
+interface GetBrotherhoodRes {
+  brotherhood: Brotherhood | undefined;
+}
+
+export const getBrotherhood = async ({ brotherhoodId }: GetBrotherhoodProps): Promise<GetBrotherhoodRes> => {
+  const data = await httpClient.get(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getBrotherhood(brotherhoodId)}`);
+  return data;
+};
+
+interface GetBrotherhoodUsersRes {
+  message: number;
+  brotherhoodUsers: BrotherhoodUser[];
+  brotherhoodUserWeeklyAnalytics: BrotherhoodUserWeeklyAnalyticLeaderboardEntry[];
+}
+
+export const getBrotherhoodUsers = async (brotherhoodId: number): Promise<GetBrotherhoodUsersRes> => {
+  const data = await httpClient.get(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getBrotherhoodUsers(brotherhoodId)}`);
+  return data;
+};
+
+export const getCurrentUserBrotherhoodUsers = async (ethereumAddress: string): Promise<GetBrotherhoodUsersRes> => {
+  const data = await httpClient.get(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getCurrentUserBrotherhoodUsers(ethereumAddress)}`,
+  );
+  return data;
+};
+
+interface EditBrotherhoodProps {
+  ethereumAddress: string;
+  name: string;
+  isPublic: boolean;
+  description: string;
+  signature?: string;
+  proxyAddress?: string;
+  profileImage: string | undefined;
+  inviteButtonName: string | undefined;
+  inviteButtonLink: string | undefined;
+}
+
+interface EditBrotherhoodRes {
+  message: string;
+  brotherhood: Brotherhood;
+}
+
+export const editBrotherhood = async (inputData: EditBrotherhoodProps): Promise<EditBrotherhoodRes> => {
+  const data = await httpClient.patch(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.editBrotherhood}`,
+    inputData,
+    getSignatureHeader(inputData.signature),
+  );
+  return data;
+};
+
+interface CreateBrotherhoodProps {
+  ethereumAddress: string;
+  profileImage: string | undefined;
+  name: string;
+  isPublic: boolean;
+  description: string;
+  signature?: string;
+  proxyAddress?: string;
+}
+
+interface CreateBrotherhoodRes {
+  message: string;
+  brotherhood: Brotherhood;
+}
+
+export const createBrotherhood = async (inputData: CreateBrotherhoodProps): Promise<CreateBrotherhoodRes> => {
+  const data = await httpClient.post(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.createBrotherhood}`,
+    inputData,
+    getSignatureHeader(inputData.signature),
+  );
+  return data;
+};
+
+interface GetCurrentUserBrotherhoodProps {
+  ethereumAddress: string;
+}
+
+interface GetCurrentUserBrotherhoodRes {
+  message: string;
+  brotherhood: Brotherhood | undefined;
+}
+
+export const getCurrentUserBrotherhood = async ({
+  ethereumAddress,
+}: GetCurrentUserBrotherhoodProps): Promise<GetCurrentUserBrotherhoodRes> => {
+  const data = await httpClient.post(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getCurrentUserBrotherhood}`, {
+    ethereumAddress,
+  });
+  return data;
+};
+
+interface GetPublicBrotherhoodsRes {
+  message: string;
+  brotherhoods: PublicBrotherhoodWithStats[];
+}
+
+export const getPublicBrotherhoods = async (): Promise<GetPublicBrotherhoodsRes> => {
+  const data = await httpClient.get(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getPublicBrotherhoods}`);
+
+  return data;
+};
+
+interface LeaveBrotherhoodProps {
+  brotherhoodId: number;
+  transferEthereumAddress: string | undefined;
+  ethereumAddress: string;
+  signature: string;
+  proxyAddress: string;
+}
+
+interface LeaveBrotherhoodRes {
+  message: string;
+}
+
+export const leaveBrotherhood = async ({
+  brotherhoodId,
+  transferEthereumAddress,
+  ethereumAddress,
+  signature,
+  proxyAddress,
+}: LeaveBrotherhoodProps): Promise<LeaveBrotherhoodRes> => {
+  const data = await httpClient.patch(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.leaveBrotherhood(brotherhoodId)}`,
+    {
+      transferEthereumAddress,
+      ethereumAddress,
+      proxyAddress,
+    },
+    getSignatureHeader(signature),
+  );
+
+  return data;
+};
+
+interface JoinBrotherhoodProps {
+  ethereumAddress: string;
+  brotherhoodId: number;
+  signature: string;
+  invitationToken?: string;
+  proxyAddress: string;
+}
+
+interface JoinBrotherhoodRes {
+  message: string;
+  brotherhood: Brotherhood;
+}
+
+export const joinBrotherhood = async ({
+  brotherhoodId,
+  ethereumAddress,
+  signature,
+  invitationToken,
+  proxyAddress,
+}: JoinBrotherhoodProps): Promise<JoinBrotherhoodRes> => {
+  const data = await httpClient.patch(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.joinBrotherhood(brotherhoodId)}`,
+    {
+      ethereumAddress,
+      invitationToken,
+      proxyAddress,
+    },
+    getSignatureHeader(signature),
+  );
+  return data;
+};

package/src/API/callLifiAPI.ts

@@ -0,0 +1,41 @@
+import { getServerURL } from './getServerURL';
+import { API_CONFIG } from '../constants/server.constants';
+import { httpClient } from '../data-structures/tor';
+
+export interface LifiRequestData {
+  fromChain: number;
+  toChain: number;
+  fromToken: string;
+  toToken: string;
+  fromAddress: string;
+  toAddress?: string; // if not specified same as fromAddress
+  fromAmount: string; // bigint-ish string
+  order: 'FASTEST' | 'CHEAPEST';
+  slippage: number; // 0.005 represents 0.5%
+}
+
+export interface LifiBridgeResponse {
+  id: string;
+  type: 'swap' | 'cross' | 'lifi';
+  tool: string;
+  transactionRequest: {
+    from: string;
+    to: string;
+    chainId: string;
+    value: string;
+    data: string;
+  };
+  estimate: {
+    tool: string;
+    fromAmount: string; // bigint-ish string
+    toAmount: string; // bigint-ish string
+    toAmountMin: string; // bigint-ish string
+  };
+}
+
+export const callLifiAPI = async (chainId: number, requestBody: LifiRequestData) => {
+  return httpClient.post<{ status: 'success'; lifiResponse: LifiBridgeResponse }>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.callLifiAPI}`,
+    requestBody,
+  );
+};

package/src/API/callMonitor.ts

@@ -0,0 +1,9 @@
+import axios from 'axios';
+import { API_CONFIG } from '../constants/server.constants';
+import { getServerURL } from './getServerURL';
+
+export const monitor = (address: string, chainId: number) =>
+  axios.post<void>(`${getServerURL(chainId)}${API_CONFIG.ROUTES.monitor}`, {
+    address,
+    chainId,
+  });

package/src/API/callOdosAPI.ts

@@ -0,0 +1,89 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { chainIds } from '../constants/chains.constants';
+import { getServerURL } from './getServerURL';
+import { Logger } from '../error-handling/logger';
+import { httpClient } from '../data-structures/tor';
+
+export interface OdosSwapRequest {
+  chainId: number;
+  inputTokens: {
+    tokenAddress: string;
+    amount: string;
+  }[];
+  outputTokens: {
+    tokenAddress: string;
+    proportion: number;
+  }[];
+  userAddr: string;
+  gasPrice?: number;
+  slippageLimitPercent?: number;
+  sourceBlacklist?: Array<string>;
+  sourceWhitelist?: Array<string>;
+  simulate?: boolean;
+  pathVizImage?: string;
+  pathVizImageConfig?: {
+    linkColors?: string[];
+    nodeColor?: string;
+    nodeTextColor?: string;
+    legendTextColor?: string;
+    width: number;
+    height: number;
+  };
+  disableRFQs?: boolean;
+  referralCode?: string;
+  compact?: boolean;
+  likeAsset?: boolean;
+}
+
+export interface OdosSwapData {
+  blockNumber: number;
+  gasEstimate: number;
+  gasEstimateValue: number;
+  inputTokens: {
+    tokenAddress: string;
+    amount: number;
+  }[];
+  outputTokens: {
+    tokenAddress: string;
+    amount: number;
+  }[];
+  netOutValues: Array<number>;
+  outValues: Array<string>;
+  transaction: {
+    gas: number;
+    gasPrice: number;
+    chainId: number;
+    value: string;
+    to: string;
+    data: string;
+    nonce: number;
+  };
+  simulation: {
+    isSuccess: boolean;
+    amountsOut: Array<number>;
+    simGasUsed: number;
+    gasEstimate: number;
+    simulationError: string;
+  };
+}
+
+// to send verification code on email through server
+export async function callOdosAPI(chainId: number, requestBody: OdosSwapRequest) {
+  // TODO: referralCode doesn't seem to work on base, why?
+  if (![chainIds.base, chainIds.localhost].includes(chainId)) {
+    requestBody.referralCode = '702077826';
+  }
+  return httpClient.post(`${getServerURL(chainId)}${API_CONFIG.ROUTES.callOdosAPI}`, requestBody);
+}
+
+export const getOdosPriceForToken = async (chainId: number, tokenAddress: string): Promise<number | undefined> => {
+  try {
+    const response = await httpClient.get<{ price: number }>(
+      `${getServerURL(chainId)}${API_CONFIG.ROUTES.getOdosPriceForToken(tokenAddress)}`,
+    );
+    return response.price;
+  } catch (error) {
+    Logger.error('Error fetching Odos price:', error);
+    return undefined;
+  }
+};

package/src/API/callOneInchAPI.ts

@@ -0,0 +1,47 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { getNonLocalhostChainId } from '../constants/chains.constants';
+import { getServerURL } from './getServerURL';
+import { httpClient } from '../data-structures/tor';
+
+// missing some parameters, here are the only fields relevant to us.
+export interface OneInchRequest {
+  fromTokenAddress: string;
+  toTokenAddress: string;
+  // amount here should be in bigint to preserve type safety, will be converted automatically to the appropriate format
+  amount: bigint;
+  fromAddress: string;
+  slippage: number;
+  destReceiver?: string;
+  disableEstimate?: boolean;
+  allowPartialFill?: boolean;
+}
+
+// again, not all fields are listed here, only the ones that we need.
+
+export interface OneInchTx {
+  data: string; // calldata that we need to use to call the contract
+}
+
+export interface OneInchResponse {
+  tx: OneInchTx;
+  toAmount: string; // bigint-like representation
+}
+
+export const callOneInchAPI = async (chainId: number, request: OneInchRequest): Promise<OneInchResponse> => {
+  const nonLocalhostChainId = getNonLocalhostChainId(chainId);
+
+  const paramsToUse = new URLSearchParams();
+  paramsToUse.append('fromTokenAddress', request.fromTokenAddress);
+  paramsToUse.append('toTokenAddress', request.toTokenAddress);
+  paramsToUse.append('amount', `${request.amount}`);
+  paramsToUse.append('fromAddress', request.fromAddress);
+  paramsToUse.append('slippage', `${request.slippage}`);
+  if (request.destReceiver) paramsToUse.append('destReceiver', request.destReceiver);
+  if (request.disableEstimate) paramsToUse.append('disableEstimate', `${request.disableEstimate}`);
+  if (request.allowPartialFill) paramsToUse.append('allowPartialFill', `${request.allowPartialFill}`);
+  const requestBody = {
+    url: `https://api.1inch.dev/swap/v5.2/${nonLocalhostChainId}/swap?${paramsToUse}`,
+  };
+  const oneInchData = await httpClient.post(`${getServerURL(chainId)}${API_CONFIG.ROUTES.callOneInchAPI}`, requestBody);
+  return oneInchData.oneInchResponse;
+};

package/src/API/callRelayer.ts

@@ -0,0 +1,23 @@
+import { RELAYER_CONFIG } from '../constants/server.constants';
+import { CircomDataBaseJsonType, DimDataType } from '../types/circom-data.types';
+import { getRelayerURL } from './getRelayerURL';
+import { AuthorizationData } from '../types/hinkal.types';
+import { httpClient } from '../data-structures/tor';
+import { AdminDataType } from '../types/admin.types';
+
+export interface HinkalTransactionRequestBody {
+  a: [string, string];
+  b: [[string, string], [string, string]];
+  c: [string, string];
+  dimData: DimDataType;
+  circomData: CircomDataBaseJsonType;
+  withPrivateMempool?: boolean;
+  withUniswapWorkAround?: boolean;
+  authorizationData?: AuthorizationData;
+  adminData?: AdminDataType;
+}
+
+// to send verification code on email through server
+export async function callRelayerTransactAPI(chainId: number, requestBody: HinkalTransactionRequestBody) {
+  return httpClient.post(`${getRelayerURL(chainId)}${RELAYER_CONFIG.TRANSACT}`, requestBody);
+}

package/src/API/checkRisk.ts

@@ -0,0 +1,7 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { getServerURL } from './getServerURL';
+import { httpClient } from '../data-structures/tor';
+
+export const checkRisk = async (chainId: number, address: string) => {
+  return httpClient.get(`${getServerURL(chainId)}${API_CONFIG.ROUTES.checkRisk(address)}`);
+};

package/src/API/duneAPI.ts

@@ -0,0 +1,26 @@
+import axios from 'axios';
+import { getServerURL } from './getServerURL';
+import { API_CONFIG } from '../constants';
+
+interface WalletBalancesInfo {
+  amount: string;
+  decimals: number;
+  address: string;
+  chain: string;
+  chain_id: number;
+  symbol?: string;
+  value_usd?: number;
+}
+
+interface IGetPublicWalletBalance {
+  balances: WalletBalancesInfo[];
+}
+
+export const getPublicWalletBalance = async (walletAddress: string, chainId: number): Promise<WalletBalancesInfo[]> => {
+  const { balances } = (
+    await axios.get<IGetPublicWalletBalance>(
+      `${getServerURL(chainId)}${API_CONFIG.ROUTES.getPublicWalletInformation(walletAddress)}`,
+    )
+  ).data;
+  return balances;
+};