@sabaaa1/common 0.0.5 → 0.0.7

package/src/API/getCoingeckoPrice.ts

@@ -0,0 +1,59 @@
+import axios from 'axios';
+import {
+  COINGECKO_API_KEY,
+  coingeckoPriceUrl,
+  coingeckoPriceUrl2,
+  coingeckoTokenListUrl,
+  proHeader,
+} from '../constants/coingecko.constants';
+import { CoingeckoToken } from '../types/coingecko.types';
+
+export interface CoingeckoPriceResponse {
+  usd: number;
+  eth: number;
+}
+
+export async function getCoingeckoPrice(tokenId: string): Promise<CoingeckoPriceResponse> {
+  return (
+    await axios.get(coingeckoPriceUrl(tokenId), {
+      headers: { [proHeader]: COINGECKO_API_KEY || '' },
+    })
+  ).data[tokenId];
+}
+
+/**
+ * Fetches the price of a token from Coingecko API based on token address and platform.
+ * Also Coingecko API works for lowercased addresses, so that is why we lowercase inside the function.
+ * @param tokenAddress The address of the token contract.
+ * @param platform The platform identifier for the token.
+ * @returns Promise resolving to CoingeckoPriceResponse object.
+ */
+export async function getCoingeckoPrice2(tokenAddress: string, platform: string): Promise<CoingeckoPriceResponse> {
+  const lowercasedTokenAddress = tokenAddress.toLowerCase();
+
+  return (
+    await axios.get(coingeckoPriceUrl2(lowercasedTokenAddress, platform), {
+      headers: { [proHeader]: COINGECKO_API_KEY || '' },
+    })
+  ).data[tokenAddress];
+}
+
+export interface CoingeckoPricesResponse {
+  [coingeckoId: string]: {
+    usd?: number;
+    eth?: number;
+  };
+}
+
+export async function getCoingeckoPrices(tokenIds: string): Promise<CoingeckoPricesResponse> {
+  return (
+    await axios.get(coingeckoPriceUrl(tokenIds), {
+      headers: { [proHeader]: COINGECKO_API_KEY || '' },
+    })
+  ).data;
+}
+
+export async function getCoingeckoTokenList(): Promise<CoingeckoToken[]> {
+  const coinList: CoingeckoToken[] = await axios.get(coingeckoTokenListUrl);
+  return coinList;
+}

package/src/API/getGasEstimates.ts

@@ -0,0 +1,30 @@
+import { RELAYER_CONFIG } from '../constants/server.constants';
+import { getRelayerURL } from './getRelayerURL';
+import { ExternalActionId } from '../types/external-action.types';
+import { CallInfo } from '../types/API.types';
+import { httpClient } from '../data-structures/tor';
+
+interface GetGasEstimateResponse {
+  status: 'success' | 'failed';
+  priceOfTransactionInUSD?: number;
+  priceOfTransactionInToken?: number;
+}
+
+export const getGasEstimates = async (
+  chainId: number,
+  tokenAddress: string,
+  externalActionId: ExternalActionId,
+  erc20TokenAddressLength: number,
+  calls: CallInfo<string>[],
+  gasAmount?: number,
+): Promise<GetGasEstimateResponse> => {
+  return httpClient.post(
+    `${getRelayerURL(chainId)}${RELAYER_CONFIG.getGasEstimate(
+      tokenAddress,
+      externalActionId,
+      erc20TokenAddressLength,
+      gasAmount,
+    )}`,
+    { calls },
+  );
+};

package/src/API/getLifiStatus.ts

@@ -0,0 +1,35 @@
+import { getServerURL } from './getServerURL';
+import { API_CONFIG } from '../constants/server.constants';
+import { httpClient } from '../data-structures/tor';
+
+interface LifiTxStatus {
+  txHash: string;
+  amount: string;
+  token: {
+    address: string;
+    chainId: string;
+  };
+}
+
+export enum LifiStatus {
+  PENDING = 'PENDING',
+  DONE = 'DONE',
+  NOT_FOUND = 'NOT_FOUND',
+  FAILED = 'FAILED',
+}
+
+// note; only stuff that that is relevant to us
+// more info here: https://docs.li.fi/api-reference/check-the-status-of-a-cross-chain-transfer
+export interface LifiStatusResponse {
+  status: LifiStatus;
+  tool: string;
+  sending: LifiTxStatus;
+  receiving?: LifiTxStatus;
+}
+
+export const getLifiStatus = async (chainId: number, txHash: string) => {
+  const urlSearchParams = new URLSearchParams([['txHash', txHash]]);
+  return httpClient.get<{ lifiResponse: LifiStatusResponse }>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.lifiStatus}?${urlSearchParams}`,
+  );
+};

package/src/API/getRelayerURL.ts

@@ -0,0 +1,27 @@
+import { PLAYGROUND_RELAYER_URLS, PRODUCTION_RELAYER_URLS, STAGING_RELAYER_URLS } from '../constants/server.constants';
+import { chainIds } from '../constants/chains.constants';
+import { DEPLOYMENT_MODE, deploymentMode } from '../constants/vite.constants';
+
+export const getRelayerURL = (chainId: number) => {
+  let URLS;
+  if (deploymentMode === DEPLOYMENT_MODE.DEVELOPMENT) {
+    URLS = STAGING_RELAYER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.PLAYGROUND) {
+    URLS = PLAYGROUND_RELAYER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.STAGING) {
+    URLS = STAGING_RELAYER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.PRODUCTION) {
+    URLS = PRODUCTION_RELAYER_URLS;
+  } else {
+    URLS = PRODUCTION_RELAYER_URLS;
+  }
+  if (chainId === chainIds.polygon) return URLS.polygon;
+  if (chainId === chainIds.arbMainnet) return URLS.arbMainnet;
+  if (chainId === chainIds.ethMainnet) return URLS.ethMainnet;
+  if (chainId === chainIds.bnbMainnet) return URLS.bnbMainnet;
+  if (chainId === chainIds.avalanche) return URLS.avalanche;
+  if (chainId === chainIds.optimism) return URLS.optimism;
+  if (chainId === chainIds.base) return URLS.base;
+  if (chainId === chainIds.arcTestnet) return URLS.arcTestnet;
+  return URLS.ethMainnet;
+};

package/src/API/getServerURL.ts

@@ -0,0 +1,116 @@
+import { chainIds } from '../constants/chains.constants';
+import {
+  DATA_SERVER_URL_ENDPOINT,
+  PLAYGROUND_SERVER_URLS,
+  PLAYGROUND_SNAPSHOT_SERVER_URLS,
+  PLAYGROUND_URL,
+  PRODUCTION_SERVER_URLS,
+  PRODUCTION_SNAPSHOT_SERVER_URLS,
+  PRODUCTION_URL,
+  STAGING_SERVER_URLS,
+  STAGING_SNAPSHOT_SERVER_URLS,
+  STAGING_URL,
+} from '../constants/server.constants';
+import { DEPLOYMENT_MODE, deploymentMode } from '../constants/vite.constants';
+
+// SERVER URLS
+export const getServerURL = (chainId: number) => {
+  let URLS;
+  if (deploymentMode === DEPLOYMENT_MODE.DEVELOPMENT) {
+    URLS = STAGING_SERVER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.PLAYGROUND) {
+    URLS = PLAYGROUND_SERVER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.STAGING) {
+    URLS = STAGING_SERVER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.PRODUCTION) {
+    URLS = PRODUCTION_SERVER_URLS;
+  } else {
+    URLS = PRODUCTION_SERVER_URLS;
+  }
+
+  switch (chainId) {
+    case chainIds.polygon:
+      return URLS.polygon;
+    case chainIds.arbMainnet:
+      return URLS.arbMainnet;
+    case chainIds.ethMainnet:
+      return URLS.ethMainnet;
+    case chainIds.avalanche:
+      return URLS.avalanche;
+    case chainIds.bnbMainnet:
+      return URLS.bnbMainnet;
+    case chainIds.optimism:
+      return URLS.optimism;
+    case chainIds.base:
+      return URLS.base;
+    case chainIds.arcTestnet:
+      return URLS.arcTestnet;
+    case chainIds.localhost:
+      return URLS.localhost;
+    default:
+      return URLS.ethMainnet;
+  }
+};
+
+// SNAPSHOT SERVER URLS
+export const getSnapshotServerURL = (chainId: number) => {
+  let URLS;
+
+  if (deploymentMode === DEPLOYMENT_MODE.DEVELOPMENT) {
+    URLS = STAGING_SNAPSHOT_SERVER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.PLAYGROUND) {
+    URLS = PLAYGROUND_SNAPSHOT_SERVER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.STAGING) {
+    URLS = STAGING_SNAPSHOT_SERVER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.PRODUCTION) {
+    URLS = PRODUCTION_SNAPSHOT_SERVER_URLS;
+  } else {
+    URLS = PRODUCTION_SNAPSHOT_SERVER_URLS;
+  }
+
+  switch (chainId) {
+    case chainIds.polygon:
+      return URLS.polygon;
+    case chainIds.arbMainnet:
+      return URLS.arbMainnet;
+    case chainIds.ethMainnet:
+      return URLS.ethMainnet;
+    case chainIds.avalanche:
+      return URLS.avalanche;
+    case chainIds.bnbMainnet:
+      return URLS.bnbMainnet;
+    case chainIds.optimism:
+      return URLS.optimism;
+    case chainIds.base:
+      return URLS.base;
+    case chainIds.arcTestnet:
+      return URLS.arcTestnet;
+    case chainIds.localhost:
+      return URLS.localhost;
+    default:
+      return URLS.ethMainnet;
+  }
+};
+
+// DATA SERVER URLS
+export const getDataServerURL = () => {
+  // Uncomment this to use local data server
+  // return DATA_SERVER_URL_LOCAL;
+
+  switch (deploymentMode) {
+    case DEPLOYMENT_MODE.DEVELOPMENT:
+      return `${STAGING_URL}${DATA_SERVER_URL_ENDPOINT}`;
+
+    case DEPLOYMENT_MODE.PLAYGROUND:
+      return `${PLAYGROUND_URL}${DATA_SERVER_URL_ENDPOINT}`;
+
+    case DEPLOYMENT_MODE.STAGING:
+      return `${STAGING_URL}${DATA_SERVER_URL_ENDPOINT}`;
+
+    case DEPLOYMENT_MODE.PRODUCTION:
+    default:
+      return `${PRODUCTION_URL}${DATA_SERVER_URL_ENDPOINT}`;
+  }
+};
+
+export const DATA_SERVER_URL = getDataServerURL();

package/src/API/getTokenPrice.ts

@@ -0,0 +1,39 @@
+import { RELAYER_CONFIG } from '../constants/server.constants';
+import { getRelayerURL } from './getRelayerURL';
+import { httpClient } from '../data-structures/tor';
+
+interface GetTokenPriceInterface {
+  price: number;
+  status: 'success' | 'failed';
+}
+// to send verification code on email through server
+export async function getTokenPrice(
+  chainId: number,
+  erc20Address?: string,
+  id?: string,
+): Promise<GetTokenPriceInterface> {
+  return httpClient.post(`${getRelayerURL(chainId)}${RELAYER_CONFIG.getTokenPrice}`, {
+    erc20Address,
+    id,
+  });
+}
+
+interface GetTokenPriceEthInterface {
+  usd: number;
+  eth: number;
+  status: 'success' | 'failed';
+}
+
+export async function getTokenPriceEth(chainId: number, id: string): Promise<GetTokenPriceEthInterface> {
+  return httpClient.get(`${getRelayerURL(chainId)}${RELAYER_CONFIG.getTokenPriceEth(id)}`);
+}
+
+interface IGetPrices {
+  prices: number[];
+}
+export const getTokenPrices = async (chainId: number, erc20Addresses: string[]): Promise<IGetPrices> => {
+  const prices = await httpClient.post<IGetPrices>(`${getRelayerURL(chainId)}${RELAYER_CONFIG.getTokenPrices}`, {
+    erc20Addresses,
+  });
+  return prices;
+};

package/src/API/getWebsiteURL.ts

@@ -0,0 +1,58 @@
+import { DEPLOYMENT_MODE, deploymentMode } from '../constants';
+
+const localhostHinkalLanding = 'http://localhost:4230';
+const playgroundHinkalLanding = 'https://hinkal-playground-landing.netlify.app';
+const stagingHinkalLanding = 'https://staging-hinkal-landing.netlify.app';
+const hinkalLanding = 'https://hinkal.pro';
+
+const localhostWalletOnboarding = 'http://localhost:4118';
+const playgroundWalletOnboarding = 'https://hinkal-playground-onboarding.netlify.app';
+const stagingWalletOnboarding = 'https://staging-hinkal-onboarding.netlify.app';
+const productionWalletOnboarding = 'https://onboarding.hinkal.pro';
+
+const localhostRewardsOrigin = 'http://localhost:4117';
+const playgroundRewardsOrigin = 'https://hinkal-playground.netlify.app';
+const stagingRewardsOrigin = 'https://staging-hinkal-rewards.netlify.app';
+const rewardsOrigin = 'https://rewards.hinkal.pro';
+
+export const getHinkalLandingURL = () => {
+  switch (deploymentMode) {
+    case DEPLOYMENT_MODE.DEVELOPMENT:
+      return localhostHinkalLanding;
+    case DEPLOYMENT_MODE.PLAYGROUND:
+      return playgroundHinkalLanding;
+    case DEPLOYMENT_MODE.STAGING:
+      return stagingHinkalLanding;
+    case DEPLOYMENT_MODE.PRODUCTION:
+    default:
+      return hinkalLanding;
+  }
+};
+
+export const getWalletOnboardingURL = () => {
+  switch (deploymentMode) {
+    case DEPLOYMENT_MODE.DEVELOPMENT:
+      return localhostWalletOnboarding;
+    case DEPLOYMENT_MODE.PLAYGROUND:
+      return playgroundWalletOnboarding;
+    case DEPLOYMENT_MODE.STAGING:
+      return stagingWalletOnboarding;
+    case DEPLOYMENT_MODE.PRODUCTION:
+    default:
+      return productionWalletOnboarding;
+  }
+};
+
+export const getRewardsURL = () => {
+  switch (deploymentMode) {
+    case DEPLOYMENT_MODE.DEVELOPMENT:
+      return localhostRewardsOrigin;
+    case DEPLOYMENT_MODE.PLAYGROUND:
+      return playgroundRewardsOrigin;
+    case DEPLOYMENT_MODE.STAGING:
+      return stagingRewardsOrigin;
+    case DEPLOYMENT_MODE.PRODUCTION:
+    default:
+      return rewardsOrigin;
+  }
+};

package/src/API/is-tx-stateless.ts

@@ -0,0 +1,32 @@
+import { TxParametersBase } from '../types/wc.types';
+import { getServerURL } from './getServerURL';
+import { API_CONFIG } from '../constants/server.constants';
+import { TransactionSimulatorResult, VolatileTokenTransferResult } from '../types/TransactionSimulator.types';
+import { httpClient } from '../data-structures/tor';
+import { VolatileTokenChange } from '../types';
+
+export const isTxStateless = async (
+  chainId: number,
+  txParameters: TxParametersBase,
+  simulateRandomUserTx: boolean,
+): Promise<TransactionSimulatorResult<string>> => {
+  return httpClient.post<TransactionSimulatorResult<string>>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.isTxStateless}`,
+    {
+      txParameters,
+      simulateRandomUserTx,
+    },
+  );
+};
+
+export const simulateVolatileTokenTransfer = async (
+  chainId: number,
+  tokenTransfers: VolatileTokenChange[],
+): Promise<VolatileTokenTransferResult[]> => {
+  return httpClient.post<VolatileTokenTransferResult[]>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.simulateVolatileTokenTransfer}`,
+    {
+      tokenTransfers,
+    },
+  );
+};

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;
+};