squarefi-bff-api-module 1.0.0

package/src/api/user.ts

@@ -0,0 +1,24 @@
+import { API } from './types';
+
+import { apiClientV2 } from '.';
+
+export const user = {
+  get: () => apiClientV2.getRequest<API.User.User>('/user'),
+  userData: {
+    get: () => apiClientV2.getRequest<API.User.UserData.UserData>('/user/user-data'),
+    update: (data: API.User.UserData.UpdateUserData.Request) =>
+      apiClientV2.patchRequest<API.User.UserData.UpdateUserData.Response>('/user/user-data', { data }),
+  },
+  update: {
+    phone: {
+      request: (data: API.User.UpdateUser.Phone.RequestOTP.Request) =>
+        apiClientV2.patchRequest('/user/phone', { data }),
+      confirm: (data: API.User.UpdateUser.Phone.Confirm.Request) => apiClientV2.postRequest('/user/phone', { data }),
+    },
+    email: {
+      request: (data: API.User.UpdateUser.Email.RequestOTP.Request) =>
+        apiClientV2.patchRequest('/user/email', { data }),
+      confirm: (data: API.User.UpdateUser.Email.Confirm.Request) => apiClientV2.postRequest('/user/email', { data }),
+    },
+  },
+};

package/src/api/wallets.ts

@@ -0,0 +1,39 @@
+import { API } from './types';
+
+import { apiClientV2 } from '.';
+
+import { defaultPaginationParams, WalletTypeValues } from '../constants';
+
+export const wallets = {
+  create: (type: WalletTypeValues) => apiClientV2.postRequest('/wallets', { data: { type } }).then(({ data }) => data),
+  getAll: () => apiClientV2.getRequest<API.Wallets.WalletsList.Response>('/wallets').then(({ data }) => data),
+  getByUuid: (uuid: string) => apiClientV2.getRequest<API.Wallets.Wallet>(`/wallets/${uuid}`).then(({ data }) => data),
+  addresses: {
+    create: ({ wallet_uuid, chain, label }: API.Wallets.WalletChain.Create.Request) =>
+      apiClientV2
+        .postRequest<API.Wallets.WalletChain.Create.Response>(`/wallets/${wallet_uuid}/addresses/${chain}`, {
+          data: { label },
+        })
+        .then(({ data }) => data),
+    get: {
+      byWalletUuid: {
+        byChainId: (wallet_uuid: string, chain_id: number) =>
+          apiClientV2
+            .getRequest<API.Wallets.WalletChain.WalletChain>(`/wallets/${wallet_uuid}/addresses/${chain_id}`)
+            .then(({ data }) => data),
+      },
+    },
+  },
+  transactions: {
+    getByWalletUuid: async (
+      wallet_uuid: string,
+      limit = defaultPaginationParams.limit,
+      offset = defaultPaginationParams.offset
+    ) =>
+      apiClientV2
+        .getRequest<API.Wallets.WalletTransactions.TransactionList.Response>(`/wallets/${wallet_uuid}/transactions`, {
+          params: { limit, offset },
+        })
+        .then(({ data }) => data),
+  },
+};

package/src/constants.ts

@@ -0,0 +1,180 @@
+export type ValueWithLabel = {
+  value: string;
+  label: string;
+};
+
+export type WalletType = {
+  [key: string]: ValueWithLabel;
+};
+
+export const falsyValues = ['false', '0', '', 'FALSE', false, null, undefined, NaN, 0];
+
+export enum AppEnviroment {
+  WEB = 'web',
+  TELEGRAM = 'telegram',
+}
+
+export enum CardFormFactor {
+  VIRTUAL = 'VIRTUAL',
+  PHYSICAL = 'PHYSICAL',
+}
+
+export enum CardType {
+  CREDIT = 'CREDIT',
+  DEBIT = 'DEBIT',
+}
+
+export enum CardTransactionType {
+  AUTHORIZATION = 'AUTHORIZATION',
+  CLEARING = 'CLEARING',
+  REFUND = 'REFUND',
+  REVERSAL = 'REVERSAL',
+  ORIGINAL_CREDIT = 'ORIGINAL_CREDIT',
+  FEE = 'FEE',
+  DEPOSIT = 'DEPOSIT',
+  WITHDRAWAL = 'WITHDRAWAL',
+}
+
+export enum WalletTransactionType {
+  DEPOSIT = 'deposit',
+  WITHDRAWAL = 'withdrawal',
+}
+
+export enum WalletTransactionMethod {
+  P2P = 'p2p',
+  CRYPTO = 'crypto',
+  BANK_TRANSFER = 'bank_transfer',
+  EXCHANGE = 'exchange',
+  SBP = 'sbp',
+}
+
+export enum WalletTransactionRecordType {
+  CARD_PROVIDER_DEPOSIT = 'CARD_PROVIDER_DEPOSIT',
+  CARD_PROVIDER_REFUND = 'CARD_PROVIDER_REFUND',
+  DEPOSIT = 'DEPOSIT',
+  DEPOSIT_CRYPTO_EXTERNAL = 'DEPOSIT_CRYPTO_EXTERNAL',
+  DEPOSIT_CRYPTO_INTERNAL = 'DEPOSIT_CRYPTO_INTERNAL',
+  EXCHANGE_CRYPTO_INTERNAL = 'EXCHANGE_CRYPTO_INTERNAL',
+  EXT_EXCHANGE = 'EXT_EXCHANGE',
+  FEE = 'FEE',
+  NETWORK_FEE = 'NETWORK_FEE',
+  REFUND = 'REFUND',
+  WITHDRAWAL = 'WITHDRAWAL',
+  WITHDRAWAL_CRYPTO_EXTERNAL = 'WITHDRAWAL_CRYPTO_EXTERNAL',
+  WITHDRAWAL_CRYPTO_INTERNAL = 'WITHDRAWAL_CRYPTO_INTERNAL',
+  WHOLESALE_CARD_DEPOSIT = 'WHOLESALE_CARD_DEPOSIT',
+}
+
+export enum RequestStatus {
+  NONE = 'none',
+  PENDING = 'pending',
+  FULLFILLED = 'fulfilled',
+  REJECTED = 'rejected',
+}
+
+export enum RequestLoadingType {
+  NORMAL = 'normal',
+  TRANSPARENT = 'transparent',
+}
+
+export enum ResponseStatus {
+  BAD_REQUEST = 400,
+  UNAUTHORIZED = 401,
+  FORBIDDEN = 403,
+  NOT_FOUND = 404,
+  VERIFICATION_EXPIRED = 419,
+  UNPROCESSABLE_ENTITY = 422,
+  USER_BLOCKED = 423,
+  SERVER_ERROR = 500,
+}
+
+export enum WalletTypeValues {
+  BUSINESS = 'business',
+  PERSONAL = 'personal',
+  P2P = 'trading',
+  ESCROW = 'escrow',
+  MERCHANT = 'merchant',
+  EXCHANGE = 'exchange',
+  STAKING = 'staking',
+  VAULT = 'vault',
+}
+
+export const walletType: WalletType = {
+  personal: { value: WalletTypeValues.PERSONAL, label: 'Personal' },
+  p2p: { value: 'p2p', label: 'P2P' },
+  escrow: { value: WalletTypeValues.ESCROW, label: 'Escrow' },
+  merchant: { value: WalletTypeValues.MERCHANT, label: 'Merchant' },
+  exchange: { value: WalletTypeValues.EXCHANGE, label: 'Exchange' },
+  staking: { value: WalletTypeValues.STAKING, label: 'Staking' },
+  vault: { value: WalletTypeValues.VAULT, label: 'Vault' },
+};
+
+export const defaultPaginationParams = {
+  limit: 10,
+  offset: 0,
+  isLastPage: true,
+};
+
+export enum KYCStatuses {
+  APPROVED = 'APPROVED',
+  DECLINED = 'DECLINED',
+  PENDING = 'PENDING',
+  HOLD = 'HOLD',
+  DOUBLE = 'DOUBLE',
+  SOFT_REJECT = 'SOFT_REJECT',
+  REJECT = 'REJECT',
+  UNVERIFIED = 'UNVERIFIED',
+}
+
+export enum OrderStatuses {
+  NEW = 'NEW',
+  PENDING = 'PENDING',
+  CANCELED = 'CANCELED',
+  COMPLETE = 'COMPLETE',
+  ERROR = 'ERROR',
+  FAILED = 'FAILED',
+}
+
+export enum CardStatus {
+  ACTIVE = 'ACTIVE',
+  FROZEN = 'FROZEN',
+  BLOCKED = 'BLOCKED',
+  INACTIVE = 'INACTIVE',
+  CANCELED = 'CANCELED',
+  CLOSED = 'CLOSED',
+}
+
+export enum FiatAccountStatus {
+  ACTIVE = 'ACTIVE',
+  BLOCKED = 'BLOCKED',
+  INACTIVE = 'INACTIVE',
+  CANCELED = 'CANCELED',
+}
+
+export enum SubAccountType {
+  PREPAID = 'prepaid',
+  BALANCE = 'balance',
+}
+
+export enum CurrencyType {
+  TOKEN = 'token',
+  NATIVE = 'native',
+  FIAT = 'fiat',
+}
+
+export enum OrderType {
+  DEPOSIT_FIAT_SEPA = 'DEPOSIT_FIAT_SEPA',
+  DEPOSIT_FIAT_SWIFT = 'DEPOSIT_FIAT_SWIFT',
+  WITHDRAWAL_FIAT_SEPA = 'WITHDRAWAL_FIAT_SEPA',
+  TRANSFER_CARD_PREPAID = 'TRANSFER_CARD_PREPAID',
+  TRANSFER_CARD_SUBACCOUNT = 'TRANSFER_CARD_SUBACCOUNT',
+  WITHDRAWAL_CRYPTO = 'WITHDRAWAL_CRYPTO',
+  EXCHANGE_CRYPTO_INTERNAL = 'EXCHANGE_CRYPTO_INTERNAL',
+  TRANSFER_CARD_WHOLESALE = 'TRANSFER_CARD_WHOLESALE',
+}
+
+export enum APIKeyRole {
+  READ_ONLY = 'READ_ONLY',
+  DEVELOPER = 'DEVELOPER',
+  PRODUCTION = 'PRODUCTION',
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './api';
+export * from './utils/apiClientFactory';
+export * from './utils/tokensFactory';
+export * from './constants';
+
+// Also export types if you have any
+export * from './api/types';

package/src/utils/apiClientFactory.ts

@@ -0,0 +1,154 @@
+/* eslint-disable no-console */
+import { isTMA } from '@telegram-apps/sdk-react';
+import axios, { AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+
+import { telegramSignUpPath, telegramSignInPath, refreshTokenPath } from '../api/auth';
+
+import { AppEnviroment, ResponseStatus } from '../constants';
+import { getFromLocalStorage } from '../utils/storage';
+import { deleteTokens, refreshTokens } from '../utils/tokensFactory';
+
+// eslint-disable-next-line no-constant-condition
+
+type CreateApiClientOptions = {
+  baseURL: string;
+  tenantId: string;
+  isBearerToken?: boolean;
+};
+
+export const createApiClient = ({ baseURL, isBearerToken, tenantId }: CreateApiClientOptions) => {
+  type RequestQueueItem = {
+    resolve: Function;
+    reject: Function;
+  };
+
+  const instance = axios.create({
+    baseURL,
+    timeout: 60000,
+  });
+
+  instance.interceptors.request.use((config) => {
+    const access_token = getFromLocalStorage('access_token');
+
+    const modifiedHeaders = {
+      ...config.headers,
+      'App-Enviroment': isTMA() ? AppEnviroment.TELEGRAM : AppEnviroment.WEB,
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': '*',
+      'x-tenant-id': tenantId,
+    };
+
+    if (access_token) {
+      const authHeader = isBearerToken ? `Bearer ${access_token}` : access_token;
+      modifiedHeaders.Authorization = authHeader;
+    }
+
+    return { ...config, headers: modifiedHeaders } as unknown as InternalAxiosRequestConfig;
+  });
+
+  let isTokenRefreshing = false;
+  let requestQueue: RequestQueueItem[] = [];
+
+  instance.interceptors.response.use(
+    (response) => response,
+    (error) => {
+      if (typeof window === 'undefined') {
+        return Promise.reject(error);
+      }
+      if (error?.response?.status === ResponseStatus.UNAUTHORIZED) {
+        const { response, config: failedRequest } = error;
+        const refreshToken = getFromLocalStorage('refresh_token');
+        const isRetryRequest = failedRequest.headers['X-Retry-Request'];
+
+        const isRefreshTokenRequest = response?.config?.url.includes(refreshTokenPath);
+        const isTelegramSignInRequest = response?.config?.url.includes(telegramSignInPath);
+        const isTelegramSignUpRequest = response?.config?.url.includes(telegramSignUpPath);
+        const isRefreshNotRequired = !refreshToken && !isTMA();
+        const isLogoutNeccesary =
+          isRefreshNotRequired ||
+          isTelegramSignInRequest ||
+          isTelegramSignUpRequest ||
+          isRefreshTokenRequest ||
+          isRetryRequest;
+
+        const isRefreshAvailable = (!isTokenRefreshing && typeof refreshToken === 'string') || isTMA();
+
+        if (isLogoutNeccesary) {
+          if (typeof window !== 'undefined') {
+            // navigate('/auth/logout');
+            deleteTokens();
+          }
+          requestQueue = [];
+          return Promise.reject(response);
+        }
+        if (isRefreshAvailable) {
+          refreshTokens()
+            .then((data) => {
+              if (data?.access_token) {
+                requestQueue.forEach((request) => request.resolve());
+                requestQueue = [];
+              }
+            })
+            .catch((tokenRefreshError) => {
+              if (typeof window !== 'undefined') {
+                // navigate('/auth/logout');
+                deleteTokens();
+              }
+              requestQueue = [];
+              return Promise.reject(tokenRefreshError);
+            })
+            .finally(() => {
+              isTokenRefreshing = false;
+            });
+        }
+        return new Promise((res, rej) => {
+          requestQueue.push({
+            resolve: () => {
+              failedRequest.headers['X-Retry-Request'] = 'true';
+              return res(instance(failedRequest));
+            },
+            reject: () => rej(instance(failedRequest)),
+          });
+        });
+      }
+
+      console.error('Axios error', error);
+
+      return Promise.reject(error);
+    }
+  );
+
+  const patchRequest = async <T>(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>> => {
+    const { data = {}, ...restConfig } = config ?? {};
+
+    const res = await instance.patch(url, data, restConfig);
+
+    return res;
+  };
+
+  const postRequest = async <T>(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>> => {
+    const { data = {}, ...restConfig } = config ?? {};
+
+    const res = await instance.post(url, data, restConfig);
+
+    return res;
+  };
+
+  const deleteRequest = async (url: string, config?: AxiosRequestConfig) => {
+    const { data = {}, ...restConfig } = config ?? {};
+
+    const res = await instance.delete(url, { data, ...restConfig });
+
+    return res;
+  };
+
+  const getRequest = async <T>(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>> => {
+    const { params = {}, ...restConfig } = config ?? {};
+
+    const res = await instance.get(url, { params, ...restConfig });
+
+    return res;
+  };
+
+  return { patchRequest, postRequest, deleteRequest, getRequest };
+};

package/src/utils/storage.ts

@@ -0,0 +1,29 @@
+export const getFromLocalStorage = (key: string) => {
+  if (typeof window === 'undefined') {
+    // eslint-disable-next-line no-console
+    console.error('call getFromLocalStorage in server side');
+    return null;
+  }
+
+  return localStorage.getItem(key);
+};
+
+export const setToLocalStorage = (key: string, value: string) => {
+  if (typeof window === 'undefined') {
+    // eslint-disable-next-line no-console
+    console.error('call setToLocalStorage in server side');
+    return;
+  }
+
+  localStorage.setItem(key, value);
+};
+
+export const deleteFromLocalStorage = (key: string) => {
+  if (typeof window === 'undefined') {
+    // eslint-disable-next-line no-console
+    console.error('call deleteFromLocalStorage in server side');
+    return;
+  }
+
+  localStorage.removeItem(key);
+};

package/src/utils/tokensFactory.ts

@@ -0,0 +1,50 @@
+import { initData, isTMA } from '@telegram-apps/sdk-react';
+
+import { deleteFromLocalStorage, getFromLocalStorage, setToLocalStorage } from './storage';
+
+import { auth } from '../api/auth';
+
+type SetTokensProps = {
+  access_token: string;
+  refresh_token?: string;
+};
+
+export function setTokens({ access_token, refresh_token }: SetTokensProps) {
+  access_token && setToLocalStorage('access_token', access_token);
+  refresh_token && setToLocalStorage('refresh_token', refresh_token);
+}
+
+export function deleteTokens() {
+  deleteFromLocalStorage('access_token');
+  deleteFromLocalStorage('refresh_token');
+}
+
+export async function refreshTokens() {
+  const refreshToken = getFromLocalStorage('refresh_token');
+
+  if (!refreshToken && !isTMA()) {
+    return null;
+  }
+
+  const refreshHandler = () =>
+    isTMA()
+      ? auth.signin.telegram({
+          tg_id: initData.user()?.id as number,
+          hash: initData.hash() as string,
+          init_data_raw: initData.raw() as string,
+        })
+      : auth.refresh.refresh_token(refreshToken as string);
+
+  const { data } = await refreshHandler();
+
+  setTokens(data);
+
+  return data;
+}
+
+export function getTokens() {
+  return {
+    access_token: getFromLocalStorage('access_token'),
+    refresh_token: getFromLocalStorage('refresh_token'),
+  };
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "**/__tests__/*"]
+}