squarefi-bff-api-module 1.0.0

package/dist/utils/tokensFactory.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setTokens = setTokens;
+exports.deleteTokens = deleteTokens;
+exports.refreshTokens = refreshTokens;
+exports.getTokens = getTokens;
+const sdk_react_1 = require("@telegram-apps/sdk-react");
+const storage_1 = require("./storage");
+const auth_1 = require("../api/auth");
+function setTokens({ access_token, refresh_token }) {
+    access_token && (0, storage_1.setToLocalStorage)('access_token', access_token);
+    refresh_token && (0, storage_1.setToLocalStorage)('refresh_token', refresh_token);
+}
+function deleteTokens() {
+    (0, storage_1.deleteFromLocalStorage)('access_token');
+    (0, storage_1.deleteFromLocalStorage)('refresh_token');
+}
+function refreshTokens() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const refreshToken = (0, storage_1.getFromLocalStorage)('refresh_token');
+        if (!refreshToken && !(0, sdk_react_1.isTMA)()) {
+            return null;
+        }
+        const refreshHandler = () => {
+            var _a;
+            return (0, sdk_react_1.isTMA)()
+                ? auth_1.auth.signin.telegram({
+                    tg_id: (_a = sdk_react_1.initData.user()) === null || _a === void 0 ? void 0 : _a.id,
+                    hash: sdk_react_1.initData.hash(),
+                    init_data_raw: sdk_react_1.initData.raw(),
+                })
+                : auth_1.auth.refresh.refresh_token(refreshToken);
+        };
+        const { data } = yield refreshHandler();
+        setTokens(data);
+        return data;
+    });
+}
+function getTokens() {
+    return {
+        access_token: (0, storage_1.getFromLocalStorage)('access_token'),
+        refresh_token: (0, storage_1.getFromLocalStorage)('refresh_token'),
+    };
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "squarefi-bff-api-module",
+  "version": "1.0.0",
+  "description": "Squarefi BFF API client module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "test": "jest"
+  },
+  "keywords": [
+    "squarefi",
+    "api",
+    "client",
+    "typescript"
+  ],
+  "author": "Your Name",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "1.6.7",
+    "@telegram-apps/sdk-react": "3.1.2",
+    "react-icons": "5.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.x.x",
+    "typescript": "^5.x.x",
+    "@types/jest": "^29.x.x",
+    "jest": "^29.x.x",
+    "ts-jest": "^29.x.x"
+  },
+  "peerDependencies": {
+    "react": "^18.x.x"
+  }
+}

package/src/api/auth.ts

@@ -0,0 +1,50 @@
+import { API } from './types';
+
+import { apiClientV2 } from '.';
+
+export const telegramSignInPath = '/auth/sign-in/telegram';
+export const telegramSignUpPath = '/auth/sign-up/telegram';
+export const refreshTokenPath = '/auth/refresh/refresh-token';
+
+export const auth = {
+  otp: {
+    verify: {
+      email: (email: string, token: string) =>
+        apiClientV2.postRequest<API.Auth.VerifyOtp.Response>('/auth/verify/email/otp', {
+          data: { email, token, type: 'email' },
+        }),
+      phone: (phone: string, token: string) =>
+        apiClientV2.postRequest<API.Auth.VerifyOtp.Response>('/auth/verify/phone/otp', {
+          data: { phone, token, type: 'sms' },
+        }),
+    },
+  },
+  signin: {
+    omni: {
+      email: (data: API.Auth.SignIn.Email.OTP.Request) =>
+        apiClientV2.postRequest('/auth/sign-in/omni/email/otp', { data }),
+      phone: (data: API.Auth.SignIn.Phone.OTP.Request) =>
+        apiClientV2.postRequest('/auth/sign-in/omni/phone/otp', { data }),
+    },
+    telegram: (data: API.Auth.Telegram.Signin) =>
+      apiClientV2.postRequest<API.Auth.Tokens>(telegramSignInPath, { data }),
+    password: (
+      email: string,
+      password: string, // check on backend V2
+    ) =>
+      apiClientV2.postRequest<API.Auth.SupabaseGetSessionResponse>('/auth/sign-in/password', {
+        data: { email, password },
+      }),
+  },
+  signup: {
+    password: (email: string, password: string) =>
+      apiClientV2.postRequest<API.Auth.SupabaseGetSessionResponse>('/auth/sign-up/password', {
+        data: { email, password },
+      }),
+    telegram: (data: API.Auth.Telegram.Signup) => apiClientV2.postRequest(telegramSignUpPath, { data }),
+  },
+  refresh: {
+    refresh_token: (refresh_token: string) =>
+      apiClientV2.postRequest<API.Auth.Tokens>(refreshTokenPath, { data: { refresh_token } }),
+  },
+};

package/src/api/developer.ts

@@ -0,0 +1,18 @@
+import { API } from './types';
+
+import { apiClientV1 } from '.';
+
+export const developer = {
+  apiKeys: {
+    getAll: () => apiClientV1.getRequest<API.Developer.ApiCode.ApiCode[]>('/developer/access/list'),
+    create: (data: API.Developer.ApiCode.Create.Request) =>
+      apiClientV1.postRequest<API.Developer.ApiCode.Create.Response>('/developer/access/create', { data }),
+    rotate: (data: API.Developer.ApiCode.Rotate.Request) =>
+      apiClientV1.postRequest<API.Developer.ApiCode.Rotate.Response>(`/developer/access/rotate`, { data }),
+    update: (data: API.Developer.ApiCode.Update.Request) =>
+      apiClientV1.postRequest(`/developer/access/update`, { data }),
+  },
+  vendors: {
+    list: () => apiClientV1.getRequest<API.Developer.Vendors.Vendor[]>('/developer/vendors/list'),
+  },
+};

package/src/api/exchange.ts

@@ -0,0 +1,32 @@
+import { API } from './types';
+
+import { apiClientV1 } from '.';
+
+import { OrderType } from '../constants';
+
+const createOrderTypeMethods = (orderType: OrderType) => ({
+  getByFromCurrency: (from_uuid: string) =>
+    apiClientV1
+      .getRequest<API.Exchange.Exchange[]>('/exchange/', { params: { from_uuid, order_type: orderType } })
+      .then(({ data }) => data),
+  getByToCurrency: (to_uuid: string) =>
+    apiClientV1
+      .getRequest<API.Exchange.Exchange[]>('/exchange/', { params: { to_uuid, order_type: orderType } })
+      .then(({ data }) => data),
+  getByOrderType: () =>
+    apiClientV1
+      .getRequest<API.Exchange.Exchange[]>('/exchange/', { params: { order_type: orderType } })
+      .then(({ data }) => data),
+});
+
+export const exchange = {
+  byOrderType: {
+    [OrderType.DEPOSIT_FIAT_SEPA]: createOrderTypeMethods(OrderType.DEPOSIT_FIAT_SEPA),
+    [OrderType.DEPOSIT_FIAT_SWIFT]: createOrderTypeMethods(OrderType.DEPOSIT_FIAT_SWIFT),
+    [OrderType.WITHDRAWAL_FIAT_SEPA]: createOrderTypeMethods(OrderType.WITHDRAWAL_FIAT_SEPA),
+    // [OrderType.TRANSFER_CARD_PREPAID]: createOrderTypeMethods(OrderType.TRANSFER_CARD_PREPAID), // DO not used
+    [OrderType.TRANSFER_CARD_SUBACCOUNT]: createOrderTypeMethods(OrderType.TRANSFER_CARD_SUBACCOUNT),
+    [OrderType.WITHDRAWAL_CRYPTO]: createOrderTypeMethods(OrderType.WITHDRAWAL_CRYPTO),
+    [OrderType.EXCHANGE_CRYPTO_INTERNAL]: createOrderTypeMethods(OrderType.EXCHANGE_CRYPTO_INTERNAL),
+  },
+};

package/src/api/fiat_accounts.ts

@@ -0,0 +1,69 @@
+import { API } from './types';
+
+import { apiClientV2, apiClientV1 } from '.';
+
+export const fiat_accounts_v2 = {
+  list: {
+    withCards: {
+      getAll: (wallet_uuid: string, limit: number, offset: number) =>
+        apiClientV2.getRequest<API.FiatAccountsV2.FiatAccountsListWithCards>(`/fiat-accounts/${wallet_uuid}`, {
+          params: { limit, offset, show_cards: true },
+        }),
+    },
+    withoutCards: {
+      getAll: (wallet_uuid: string, limit: number, offset: number) =>
+        apiClientV2.getRequest<API.FiatAccountsV2.FiatAccountsListWithoutCards>(`/fiat-accounts/${wallet_uuid}`, {
+          params: { limit, offset },
+        }),
+    },
+  },
+
+  getByUuid: ({ wallet_uuid, fiat_account_id }: API.FiatAccountsV2.ExtendedFiatAccount.Request) =>
+    apiClientV2.getRequest<API.FiatAccountsV2.ExtendedFiatAccount.Response>(
+      `/fiat-accounts/${wallet_uuid}/${fiat_account_id}`,
+    ),
+  create: ({ wallet_id, program_id }: API.FiatAccountsV2.CreateFiatAccount.Request) =>
+    apiClientV2.postRequest<API.FiatAccountsV2.CreateFiatAccount.Response>(`/fiat-accounts/${wallet_id}`, {
+      data: { program_id },
+    }),
+  transactions: {
+    get: ({ fiat_account_id, wallet_uuid, limit, offset }: API.FiatAccountsV2.Transactions.TransactionList.Request) =>
+      apiClientV2.getRequest<API.FiatAccountsV2.Transactions.TransactionList.Response>(
+        `/fiat-accounts/${wallet_uuid}/${fiat_account_id}/transactions`,
+        {
+          params: { limit, offset },
+        },
+      ),
+  },
+};
+
+export const fiat_accounts = {
+  list: {
+    withCards: {
+      getSinglecards: (wallet_uuid: string, limit: number, offset: number) =>
+        apiClientV1.getRequest<API.FiatAccounts.FiatAccountWithCards[]>(`/fiat_accounts/list/${wallet_uuid}`, {
+          params: { limit, offset, lt_cards_limit: 2, gt_cards_limit: 0, show_cards: true },
+        }),
+      getAll: (wallet_uuid: string, limit: number, offset: number) =>
+        apiClientV1.getRequest<API.FiatAccounts.FiatAccountWithCards[]>(`/fiat_accounts/list/${wallet_uuid}`, {
+          params: { limit, offset, show_cards: true },
+        }),
+    },
+    withoutCards: {
+      getAll: (wallet_uuid: string, limit: number, offset: number) =>
+        apiClientV1.getRequest<API.FiatAccounts.FiatAccount[]>(`/fiat_accounts/list/${wallet_uuid}`, {
+          params: { limit, offset },
+        }),
+    },
+  },
+
+  getByUuid: (uuid: string) => apiClientV1.getRequest<API.FiatAccounts.FiatAccount>(`/fiat_accounts/${uuid}`),
+  create: (wallet_id: string, program_id: string) =>
+    apiClientV1.postRequest<API.FiatAccounts.FiatAccount>(`/fiat_accounts`, { data: { wallet_id, program_id } }),
+  transactions: {
+    get: (fiat_account_id: string, limit?: number, offset?: number) =>
+      apiClientV1.getRequest<API.FiatAccounts.TransactionList>(`/fiat_accounts/${fiat_account_id}/transactions`, {
+        params: { limit, offset },
+      }),
+  },
+};

package/src/api/index.ts

@@ -0,0 +1,16 @@
+import { createApiClient } from '../utils/apiClientFactory';
+
+const apiV1BaseURL = process.env.API_URL ?? 'ENV variable API_URL is not defined';
+const apiV2BaseURL = process.env.API_V2_URL ?? 'ENV variable API_V2_URL is not defined';
+const envTenantId = process.env.TENANT_ID ?? 'ENV variable TENANT_ID is not defined';
+
+export const apiClientV1 = createApiClient({
+  baseURL: apiV1BaseURL,
+  tenantId: envTenantId,
+});
+
+export const apiClientV2 = createApiClient({
+  baseURL: apiV2BaseURL,
+  isBearerToken: true,
+  tenantId: envTenantId,
+});

package/src/api/issuing.ts

@@ -0,0 +1,66 @@
+import { AxiosResponse } from 'axios';
+
+import { fiat_accounts } from './fiat_accounts';
+import { API } from './types';
+
+import { apiClientV1 } from '.';
+
+import { defaultPaginationParams } from '../constants';
+
+export const issuing = {
+  cards: {
+    create: {
+      standAloneCard: (data: API.Cards.Create.StandAloneRequest) =>
+        apiClientV1.postRequest<API.Cards.Create.StandAloneResponse>('/issuing/cards/create', { data }),
+      fiatAccountCard: (data: API.Cards.Create.FiatAccountRequest) =>
+        apiClientV1.postRequest<API.Cards.Create.FiatAccountResponse>('/issuing/cards/balance', { data }),
+    },
+    getByWalletUuid: (params: API.Cards.CardsList.Request.ByWalletUuid) =>
+      apiClientV1.getRequest<API.Cards.CardsList.Response>('/issuing/cards', { params }),
+    getByFiatAccountAndWalletId: (params: API.Cards.CardsList.Request.ByFiatAccountAndWalletId) =>
+      apiClientV1.getRequest<API.Cards.CardsList.Response>('/issuing/cards', { params }),
+    getById: async (card_id: string): Promise<AxiosResponse<API.Cards.CardDetailItem, any>> => {
+      const { data: card, ...rest } = await apiClientV1.getRequest<API.Cards.CardDetailItem>(
+        `/issuing/cards/${card_id}`
+      );
+      const { data: fiatAccountData } = await fiat_accounts.getByUuid(card.fiat_account.id);
+
+      // const { data: fiatAccountData } = await fiat_accounts.getByUuid({ V2 API FIAT ACCOUNTS
+      //   wallet_uuid: card.fiat_account.wallet_id,
+      //   fiat_account_id: card.fiat_account.id,
+      // });
+      return { ...rest, data: { ...card, fiat_account: { ...fiatAccountData, type: card.fiat_account.type } } };
+    },
+    sensitiveData: {
+      get: (card_id: string) => apiClientV1.getRequest<API.Cards.SensitiveData>(`/issuing/cards/${card_id}/sensitive`),
+      otp: {
+        // have to update
+        get: (card_id: string) => apiClientV1.getRequest<API.Cards.OTP>(`/vcards/cards/${card_id}/sensitive/otp`),
+      },
+    },
+    close: (card_id: string) => apiClientV1.deleteRequest(`/issuing/cards/${card_id}`),
+    freeze: (card_id: string) => apiClientV1.patchRequest<API.Cards.CardDetailItem>(`/issuing/cards/${card_id}/freeze`),
+    unfreeze: (card_id: string) =>
+      apiClientV1.patchRequest<API.Cards.CardDetailItem>(`/issuing/cards/${card_id}/unfreeze`),
+  },
+  transactions: {
+    getByCardId: (card_id: string, limit = defaultPaginationParams.limit, offset = defaultPaginationParams.offset) =>
+      apiClientV1.getRequest<API.Cards.TransactionsList>(`/issuing/transactions/`, {
+        params: { limit, offset, card_id, new_scheme: true },
+      }),
+    getByFiatAccountId: (
+      fiat_account_id: string,
+      limit = defaultPaginationParams.limit,
+      offset = defaultPaginationParams.offset
+    ) =>
+      apiClientV1.getRequest<API.Cards.TransactionsList>(`/issuing/transactions/`, {
+        params: { limit, offset, fiat_account_id, new_scheme: true },
+      }),
+  },
+  config: {
+    programs: {
+      getAll: () =>
+        apiClientV1.getRequest<API.Issuing.Programs.Response>('/issuing/config/programs').then(({ data }) => data),
+    },
+  },
+};

package/src/api/kyc.ts

@@ -0,0 +1,10 @@
+import { API } from './types';
+
+import { apiClientV1 } from '.';
+
+export const kyc = {
+  sumsub: {
+    generate_token: (data: API.KYC.Sumsub.GenerateToken.Request) =>
+      apiClientV1.postRequest<API.KYC.Sumsub.GenerateToken.Response>('/kyc/sumsub/generate_token', { data }),
+  },
+};

package/src/api/list.ts

@@ -0,0 +1,18 @@
+/* eslint-disable import/prefer-default-export */
+
+import { AxiosRequestConfig } from 'axios';
+
+import { API } from './types';
+
+import { apiClientV2 } from '.';
+
+export const list = {
+  currencies: {
+    getAll: (params?: AxiosRequestConfig) =>
+      apiClientV2.getRequest<API.Currencies.CurrencyList>('/currencies', params).then(({ data }) => data),
+  },
+  chains: {
+    getAll: (params?: AxiosRequestConfig) =>
+      apiClientV2.getRequest<API.Chains.ChainList>('/chains', params).then(({ data }) => data),
+  },
+};

package/src/api/orders.ts

@@ -0,0 +1,32 @@
+import { API } from './types';
+
+import { apiClientV1 } from '.';
+
+import { OrderType } from '../constants';
+
+export const orders = {
+  calc: ({ signal, ...params }: API.Orders.Calc.Request) =>
+    apiClientV1.getRequest<API.Orders.Calc.Response>('/orders/calc', { params, signal }).then((res) => res.data),
+  create: {
+    byOrderType: {
+      [OrderType.TRANSFER_CARD_SUBACCOUNT]: (data: API.Orders.Create.ByOrderType.TRANSFER_CARD_SUBACCOUNT.Request) =>
+        apiClientV1.postRequest<API.Orders.Create.ByOrderType.TRANSFER_CARD_SUBACCOUNT.Response>(
+          '/orders/TRANSFER_CARD_SUBACCOUNT',
+          {
+            data,
+          }
+        ),
+      [OrderType.WITHDRAWAL_CRYPTO]: (data: API.Orders.Create.ByOrderType.WITHDRAWAL_CRYPTO.Request) =>
+        apiClientV1.postRequest<API.Orders.Create.ByOrderType.WITHDRAWAL_CRYPTO.Response>('/orders/WITHDRAWAL_CRYPTO', {
+          data,
+        }),
+      [OrderType.EXCHANGE_CRYPTO_INTERNAL]: (data: API.Orders.Create.ByOrderType.EXCHANGE_CRYPTO_INTERNAL.Request) =>
+        apiClientV1.postRequest<API.Orders.Create.ByOrderType.EXCHANGE_CRYPTO_INTERNAL.Response>(
+          '/orders/EXCHANGE_CRYPTO_INTERNAL',
+          { data }
+        ),
+      [OrderType.TRANSFER_CARD_WHOLESALE]: (data: API.Orders.Create.ByOrderType.TRANSFER_CARD_WHOLESALE.Request) =>
+        apiClientV1.postRequest<null>('/orders/TRANSFER_CARD_WHOLESALE', { data }),
+    },
+  },
+};