@sabaaa1/common 0.0.13 → 0.0.15

package/src/API/enclaveCalls.ts

@@ -1,23 +0,0 @@
-import { type EncryptedOutputWithSign } from '../types/commitments.types';
-import { type IUtxoConstructor } from '../data-structures/utxo/Utxo';
-import { ENCLAVE_EC2_URL } from '../functions/snarkjs/constant';
-import { httpClient } from '../data-structures/tor';
-
-type DecryptUtxoEnclaveCallResponse = {
-  utxos: IUtxoConstructor<string>[];
-  encryptedOutputs: EncryptedOutputWithSign[];
-  lastOutput: string;
-};
-
-export const decryptUtxoEnclaveCall = async (
-  chainId: number,
-  keyCiphertext: string,
-  inputCiphertext: string,
-): Promise<DecryptUtxoEnclaveCallResponse> => {
-  const enclaveResponse = await httpClient.post<DecryptUtxoEnclaveCallResponse>(`${ENCLAVE_EC2_URL}/decrypt-utxos`, {
-    chainId,
-    input: inputCiphertext,
-    key: keyCiphertext,
-  });
-  return enclaveResponse;
-};

package/src/API/fetchCommitmentsCache.ts

@@ -1,63 +0,0 @@
-import { API_CONFIG } from '../constants/server.constants';
-import { MerkleTreeJson } from '../data-structures/merkle-tree/MerkleTree';
-import { SenderAddressIndexMapJson } from '../data-structures/event-service/AbstractAccessTokenSnapshotService';
-import { ApprovedUtxo, EncryptedOutputWithSign } from '../types';
-import { getSnapshotServerURL } from './getServerURL';
-import { httpClient } from '../data-structures/tor';
-
-export interface ICommitmentsTreeSnapshot {
-  merkleTree: MerkleTreeJson;
-  latestBlockNumber: number;
-  encryptedOutputs: EncryptedOutputWithSign<string>[];
-  hinkalAddress: string;
-  chainId: number;
-}
-
-export interface IAccessTokenTreeSnapshot {
-  merkleTree: MerkleTreeJson;
-  senderAddresses: string[];
-  senderAddressIndexMap?: SenderAddressIndexMapJson;
-  latestBlockNumber: number;
-  accessTokenContractAddress: string;
-  chainId: number;
-}
-
-export interface IApprovalsSnapshot {
-  approvals: Record<string, ApprovedUtxo<string>[]>;
-  events: string[];
-  latestBlockNumber: number;
-  hinkalAddress: string;
-  chainId: number;
-}
-
-export interface INullifiersSnapshot {
-  nullifiers: string[];
-  latestBlockNumber: number;
-}
-
-export interface ISnapshotsResponse {
-  commitments: ICommitmentsTreeSnapshot;
-  accessTokens: IAccessTokenTreeSnapshot;
-  nullifiers: INullifiersSnapshot;
-  approvals: IApprovalsSnapshot;
-}
-
-export const fetchSnapshots = async (chainId: number): Promise<ISnapshotsResponse> => {
-  const { commitments, accessTokens, nullifiers, approvals } = await httpClient.get(
-    `${getSnapshotServerURL(chainId)}${API_CONFIG.ROUTES.getSnapshots}`,
-  );
-
-  const [commitmentsData, accessTokensData, nullifiersData, approvalsData] = await Promise.all([
-    httpClient.get(commitments.url).then((r) => ({ ...r, ...commitments })),
-    httpClient.get(accessTokens.url).then((r) => ({ ...r, ...accessTokens })),
-    httpClient.get(nullifiers.url).then((r) => ({ ...r, ...nullifiers })),
-    httpClient.get(approvals.url).then((r) => ({ ...r, ...approvals })),
-  ]);
-
-  return {
-    commitments: commitmentsData,
-    accessTokens: accessTokensData,
-    nullifiers: nullifiersData,
-    approvals: approvalsData,
-  };
-};

package/src/API/generate-trading-points.ts

@@ -1,77 +0,0 @@
-import { DATA_SERVER_CONFIG } from '../constants/server.constants';
-import { DATA_SERVER_URL } from './getServerURL';
-import { AppMetaData, MinimalActivity, RewardsUser, TokenChanges, TradingType, UserWeeklyAnalytic } from '../types';
-import { httpClient } from '../data-structures/tor';
-import { getSignatureHeader } from '../functions/utils/get-signature-header';
-
-interface GenerateTradingPointsProps {
-  ethereumAddress: string;
-  type: TradingType;
-  signature: string;
-  proxyAddress: string;
-  tokenChanges?: TokenChanges<bigint>[];
-  appMetaData?: AppMetaData;
-  chainId?: number;
-}
-
-interface GenerateTradingPointsRes {
-  success: boolean;
-  weeklyAnalytic: UserWeeklyAnalytic;
-}
-
-export const generateTradingPoints = async ({
-  tokenChanges,
-  ethereumAddress,
-  type,
-  signature,
-  appMetaData,
-  chainId,
-  proxyAddress,
-}: GenerateTradingPointsProps): Promise<GenerateTradingPointsRes> => {
-  return httpClient.patch(
-    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.generateTradingPoints}`,
-    {
-      tokenChanges: tokenChanges?.map(({ amount, ...rest }) => ({
-        ...rest,
-        amount: amount.toString(),
-      })),
-      ethereumAddress,
-      type,
-      appMetaData,
-      chainId,
-      proxyAddress,
-    },
-    getSignatureHeader(signature),
-  );
-};
-
-interface GenerateAumPointsProps {
-  ethereumAddress: string;
-  activity: MinimalActivity[];
-  signature?: string;
-  proxyAddress?: string;
-}
-
-interface GenerateAumPointsRes {
-  message: string;
-  user: RewardsUser;
-}
-
-export const generateAumPoints = async ({
-  ethereumAddress,
-  activity,
-  signature,
-  proxyAddress,
-}: GenerateAumPointsProps): Promise<GenerateAumPointsRes> => {
-  const data = await httpClient.post(
-    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.generateAumPoints}`,
-    {
-      ethereumAddress,
-      activity,
-      proxyAddress,
-    },
-    getSignatureHeader(signature),
-  );
-
-  return data;
-};

package/src/API/get-token-data.ts

@@ -1,12 +0,0 @@
-import { API_CONFIG } from '../constants/server.constants';
-import { getServerURL } from './getServerURL';
-import { httpClient } from '../data-structures/tor';
-
-interface TokenDataResponse {
-  totalSupply: number;
-  marketCap: number;
-}
-
-export const getTokenData = async (chainId: number, tokenSymbol: string): Promise<TokenDataResponse> => {
-  return httpClient.get<TokenDataResponse>(`${getServerURL(chainId)}${API_CONFIG.ROUTES.getTokenData(tokenSymbol)}`);
-};

package/src/API/getBridgeProtocols.ts

@@ -1,16 +0,0 @@
-import { getServerURL } from './getServerURL';
-import { API_CONFIG } from '../constants/server.constants';
-import { BridgeProtocolQuery } from '../types/bridging.types';
-import { httpClient } from '../data-structures/tor';
-
-export type BridgeProtocolMatchResult = BridgeProtocolQuery & {
-  matched: boolean;
-};
-
-export const getBridgeProtocols = async (
-  chainId: number,
-  queries: BridgeProtocolQuery[],
-): Promise<{ results: BridgeProtocolMatchResult[] }> => {
-  const response = await httpClient.post(`${getServerURL(chainId)}${API_CONFIG.ROUTES.getBridgeProtocols}`, queries);
-  return response;
-};

package/src/API/getCoingeckoPrice.ts

@@ -1,59 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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;
-};