squarefi-bff-api-module 1.28.0 → 1.29.1

package/.prettierignore

@@ -3,3 +3,4 @@ dist/
 *.min.js
 *.min.css
 package-lock.json
+

package/dist/api/orders.d.ts

@@ -12,6 +12,7 @@ export declare const orders: {
             TRANSFER_CARD_PREPAID: (data: API.Orders.Create.ByOrderType.TRANSFER_CARD_PREPAID.Request) => Promise<API.Orders.Create.ByOrderType.TRANSFER_CARD_PREPAID.Response>;
             TRANSFER_CARD_WHOLESALE: (data: API.Orders.Create.ByOrderType.TRANSFER_CARD_WHOLESALE.Request) => Promise<API.Orders.Create.ByOrderType.TRANSFER_CARD_WHOLESALE.Response>;
             EXCHANGE_CRYPTO_INTERNAL: (data: API.Orders.Create.ByOrderType.EXCHANGE_CRYPTO_INTERNAL.Request) => Promise<API.Orders.Create.ByOrderType.EXCHANGE_CRYPTO_INTERNAL.Response>;
+            EXCHANGE_OMNI: (data: API.Orders.Create.ByOrderType.EXCHANGE_OMNI.Request) => Promise<API.Orders.Create.ByOrderType.EXCHANGE_OMNI.Response>;
             WITHDRAW_CARD_PREPAID: (data: API.Orders.Create.ByOrderType.WITHDRAW_CARD_PREPAID.Request) => Promise<API.Orders.Create.ByOrderType.WITHDRAW_CARD_PREPAID.Response>;
             WITHDRAW_CARD_SUBACCOUNT: (data: API.Orders.Create.ByOrderType.WITHDRAW_CARD_SUBACCOUNT.Request) => Promise<API.Orders.Create.ByOrderType.WITHDRAW_CARD_SUBACCOUNT.Response>;
         };

package/dist/api/orders.js

@@ -43,6 +43,9 @@ exports.orders = {
                 data,
             }),
             [constants_1.OrderType.EXCHANGE_CRYPTO_INTERNAL]: (data) => apiClientFactory_1.apiClientV1.postRequest('/orders/EXCHANGE_CRYPTO_INTERNAL', { data }),
+            [constants_1.OrderType.EXCHANGE_OMNI]: (data) => apiClientFactory_1.apiClientV1.postRequest('/orders/EXCHANGE_OMNI', {
+                data,
+            }),
             [constants_1.OrderType.WITHDRAW_CARD_PREPAID]: (data) => apiClientFactory_1.apiClientV1.postRequest('/orders/WITHDRAW_CARD_PREPAID', { data }),
             [constants_1.OrderType.WITHDRAW_CARD_SUBACCOUNT]: (data) => apiClientFactory_1.apiClientV1.postRequest('/orders/WITHDRAW_CARD_SUBACCOUNT', { data }),
         },

package/dist/api/types/autogen/apiV2.types.d.ts

@@ -1771,6 +1771,7 @@ export interface components {
             usd_value_of_crypto?: string | null;
             usd_value_of_fiat?: string | null;
             occupation?: string | null;
+            occupation_other?: string | null;
             /**
              * @default UNVERIFIED
              * @enum {string}
@@ -1874,6 +1875,7 @@ export interface components {
             usd_value_of_crypto?: string | null;
             usd_value_of_fiat?: string | null;
             occupation?: string | null;
+            occupation_other?: string | null;
             /** @enum {string|null} */
             employment_status?: "EMPLOYEE" | "SELF_EMPLOYED" | "RETIRED" | "UNEMPLOYED" | "OTHER" | null;
             employment_description?: string | null;

package/dist/api/types/types.d.ts

@@ -1077,6 +1077,38 @@ export declare namespace API {
                         id: number;
                     };
                 }
+                namespace EXCHANGE_OMNI {
+                    type Request = {
+                        amount: number;
+                        wallet_uuid: string;
+                        from_uuid: string;
+                        to_uuid: string;
+                    };
+                    type Response = {
+                        created_at: string;
+                        order_uuid: string;
+                        wallet_uuid: string;
+                        from_uuid: string;
+                        to_uuid: string;
+                        amount_from: number;
+                        order_type: 'EXCHANGE_OMNI';
+                        status: OrderStatuses;
+                        amount_to: number;
+                        info: string;
+                        meta: {
+                            fee: number;
+                            order_uuid: string;
+                            to_address: string;
+                            fee_currency: string;
+                            billing_amount: number;
+                            transaction_amount: number;
+                            billing_amount_currency: string;
+                            transaction_amount_currency: string;
+                            network_fee: number;
+                        };
+                        id: string;
+                    };
+                }
                 namespace TRANSFER_CARD_WHOLESALE {
                     type Request = {
                         amount: number;
@@ -1645,7 +1677,7 @@ export declare namespace API {
                 walletAddress: string;
             }
             namespace DepositInstruction {
-                type InstructionType = 'ACH' | 'FEDWIRE' | 'SWIFT';
+                type InstructionType = 'ACH' | 'FEDWIRE' | 'SWIFT' | 'SEPA_CT';
                 interface Address {
                     city: string;
                     state: string;
@@ -1682,6 +1714,13 @@ export declare namespace API {
                     institution_address: Address;
                     account_holder_address: Address;
                 }
+                interface SEPA extends Common {
+                    instruction_type: 'SEPA_CT';
+                    iban: string;
+                    swift_bic: string;
+                    institution_address: Address;
+                    account_holder_address: Address;
+                }
                 type DepositInstruction = ACH | FEDWIRE | SWIFT | Common;
             }
             interface OrderType {

package/dist/constants.d.ts

@@ -56,6 +56,7 @@ export declare enum OrderType {
     DEPOSIT_FIAT_SEPA = "DEPOSIT_FIAT_SEPA",
     DEPOSIT_FIAT_SWIFT = "DEPOSIT_FIAT_SWIFT",
     EXCHANGE_CRYPTO_INTERNAL = "EXCHANGE_CRYPTO_INTERNAL",
+    EXCHANGE_OMNI = "EXCHANGE_OMNI",
     TRANSFER_CARD_PREPAID = "TRANSFER_CARD_PREPAID",
     CARD_ISSUING_FEE = "CARD_ISSUING_FEE",
     TRANSFER_CARD_SUBACCOUNT = "TRANSFER_CARD_SUBACCOUNT",
@@ -95,6 +96,7 @@ export declare enum WalletTransactionRecordType {
     DEPOSIT_INTERNAL = "DEPOSIT_INTERNAL",
     DEPOSIT_MANUAL = "DEPOSIT_MANUAL",
     EXCHANGE_CRYPTO_INTERNAL = "EXCHANGE_CRYPTO_INTERNAL",
+    EXCHANGE_OMNI = "EXCHANGE_OMNI",
     EXT_EXCHANGE = "EXT_EXCHANGE",
     FEE = "FEE",
     HIFI_ACH_OFFRAMP = "HIFI_ACH_OFFRAMP",

package/dist/constants.js

@@ -61,6 +61,7 @@ var OrderType;
     OrderType["DEPOSIT_FIAT_SEPA"] = "DEPOSIT_FIAT_SEPA";
     OrderType["DEPOSIT_FIAT_SWIFT"] = "DEPOSIT_FIAT_SWIFT";
     OrderType["EXCHANGE_CRYPTO_INTERNAL"] = "EXCHANGE_CRYPTO_INTERNAL";
+    OrderType["EXCHANGE_OMNI"] = "EXCHANGE_OMNI";
     OrderType["TRANSFER_CARD_PREPAID"] = "TRANSFER_CARD_PREPAID";
     OrderType["CARD_ISSUING_FEE"] = "CARD_ISSUING_FEE";
     OrderType["TRANSFER_CARD_SUBACCOUNT"] = "TRANSFER_CARD_SUBACCOUNT";
@@ -101,6 +102,7 @@ var WalletTransactionRecordType;
     WalletTransactionRecordType["DEPOSIT_INTERNAL"] = "DEPOSIT_INTERNAL";
     WalletTransactionRecordType["DEPOSIT_MANUAL"] = "DEPOSIT_MANUAL";
     WalletTransactionRecordType["EXCHANGE_CRYPTO_INTERNAL"] = "EXCHANGE_CRYPTO_INTERNAL";
+    WalletTransactionRecordType["EXCHANGE_OMNI"] = "EXCHANGE_OMNI";
     WalletTransactionRecordType["EXT_EXCHANGE"] = "EXT_EXCHANGE";
     WalletTransactionRecordType["FEE"] = "FEE";
     WalletTransactionRecordType["HIFI_ACH_OFFRAMP"] = "HIFI_ACH_OFFRAMP";

package/dist/hooks/useFileUpload.d.ts

@@ -0,0 +1,34 @@
+import { UploadFileResult } from '../utils/fileStorage';
+interface UseFileUploadOptions {
+    userId: string;
+    bucket?: string;
+    authToken?: string;
+    onSuccess?: (result: UploadFileResult) => void;
+    onError?: (error: string) => void;
+}
+interface UseFileUploadReturn {
+    upload: (file: File, fileName?: string) => Promise<UploadFileResult>;
+    uploading: boolean;
+    progress: number;
+    error: string | null;
+    result: UploadFileResult | null;
+    reset: () => void;
+}
+/**
+ * React хук для загрузки файлов в Supabase Storage
+ *
+ * @example
+ * ```tsx
+ * const { upload, uploading, error, result } = useFileUpload({
+ *   userId: 'user-123',
+ *   onSuccess: (result) => console.log('Загружено:', result.path),
+ * });
+ *
+ * const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
+ *   const file = e.target.files?.[0];
+ *   if (file) await upload(file);
+ * };
+ * ```
+ */
+export declare const useFileUpload: (options: UseFileUploadOptions) => UseFileUploadReturn;
+export {};

package/dist/hooks/useFileUpload.js

@@ -0,0 +1,98 @@
+"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.useFileUpload = void 0;
+const react_1 = require("react");
+const fileStorage_1 = require("../utils/fileStorage");
+/**
+ * React хук для загрузки файлов в Supabase Storage
+ *
+ * @example
+ * ```tsx
+ * const { upload, uploading, error, result } = useFileUpload({
+ *   userId: 'user-123',
+ *   onSuccess: (result) => console.log('Загружено:', result.path),
+ * });
+ *
+ * const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
+ *   const file = e.target.files?.[0];
+ *   if (file) await upload(file);
+ * };
+ * ```
+ */
+const useFileUpload = (options) => {
+    const { userId, bucket, authToken, onSuccess, onError } = options;
+    const [uploading, setUploading] = (0, react_1.useState)(false);
+    const [progress, setProgress] = (0, react_1.useState)(0);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [result, setResult] = (0, react_1.useState)(null);
+    const upload = (0, react_1.useCallback)((file, customFileName) => __awaiter(void 0, void 0, void 0, function* () {
+        setUploading(true);
+        setProgress(0);
+        setError(null);
+        setResult(null);
+        try {
+            // Симулируем прогресс (Supabase не предоставляет реальный progress)
+            const progressInterval = setInterval(() => {
+                setProgress((prev) => Math.min(prev + 10, 90));
+            }, 100);
+            const uploadOptions = {
+                file,
+                fileName: customFileName || `${Date.now()}-${file.name}`,
+                userId,
+                bucket,
+                contentType: file.type,
+                authToken,
+            };
+            const uploadResult = yield (0, fileStorage_1.uploadFile)(uploadOptions);
+            clearInterval(progressInterval);
+            setProgress(100);
+            setResult(uploadResult);
+            if (uploadResult.success) {
+                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(uploadResult);
+            }
+            else {
+                const errorMsg = uploadResult.error || 'Ошибка загрузки файла';
+                setError(errorMsg);
+                onError === null || onError === void 0 ? void 0 : onError(errorMsg);
+            }
+            return uploadResult;
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : 'Непредвиденная ошибка';
+            setError(errorMsg);
+            onError === null || onError === void 0 ? void 0 : onError(errorMsg);
+            setProgress(0);
+            return {
+                success: false,
+                error: errorMsg,
+            };
+        }
+        finally {
+            setUploading(false);
+        }
+    }), [userId, bucket, authToken, onSuccess, onError]);
+    const reset = (0, react_1.useCallback)(() => {
+        setUploading(false);
+        setProgress(0);
+        setError(null);
+        setResult(null);
+    }, []);
+    return {
+        upload,
+        uploading,
+        progress,
+        error,
+        result,
+        reset,
+    };
+};
+exports.useFileUpload = useFileUpload;

package/dist/hooks/useUserFiles.d.ts

@@ -0,0 +1,49 @@
+interface FileItem {
+    name: string;
+    id: string;
+    created_at: string;
+    updated_at: string;
+    signedUrl?: string;
+}
+interface UseUserFilesOptions {
+    userId: string;
+    bucket?: string;
+    autoLoad?: boolean;
+    autoGenerateUrls?: boolean;
+    urlExpiresIn?: number;
+    authToken?: string;
+}
+interface UseUserFilesReturn {
+    files: FileItem[];
+    loading: boolean;
+    error: string | null;
+    reload: () => Promise<void>;
+    deleteOne: (fileName: string) => Promise<boolean>;
+    deleteMultiple: (fileNames: string[]) => Promise<boolean>;
+    getFileUrl: (fileName: string) => Promise<string | null>;
+}
+/**
+ * React хук для работы со списком файлов пользователя
+ *
+ * @example
+ * ```tsx
+ * const { files, loading, deleteOne, getFileUrl } = useUserFiles({
+ *   userId: 'user-123',
+ *   autoLoad: true,
+ *   autoGenerateUrls: true,
+ * });
+ *
+ * return (
+ *   <ul>
+ *     {files.map(file => (
+ *       <li key={file.id}>
+ *         <a href={file.signedUrl} target="_blank">{file.name}</a>
+ *         <button onClick={() => deleteOne(file.name)}>Удалить</button>
+ *       </li>
+ *     ))}
+ *   </ul>
+ * );
+ * ```
+ */
+export declare const useUserFiles: (options: UseUserFilesOptions) => UseUserFilesReturn;
+export {};

package/dist/hooks/useUserFiles.js

@@ -0,0 +1,118 @@
+"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.useUserFiles = void 0;
+const react_1 = require("react");
+const fileStorage_1 = require("../utils/fileStorage");
+/**
+ * React хук для работы со списком файлов пользователя
+ *
+ * @example
+ * ```tsx
+ * const { files, loading, deleteOne, getFileUrl } = useUserFiles({
+ *   userId: 'user-123',
+ *   autoLoad: true,
+ *   autoGenerateUrls: true,
+ * });
+ *
+ * return (
+ *   <ul>
+ *     {files.map(file => (
+ *       <li key={file.id}>
+ *         <a href={file.signedUrl} target="_blank">{file.name}</a>
+ *         <button onClick={() => deleteOne(file.name)}>Удалить</button>
+ *       </li>
+ *     ))}
+ *   </ul>
+ * );
+ * ```
+ */
+const useUserFiles = (options) => {
+    const { userId, bucket, autoLoad = true, autoGenerateUrls = false, urlExpiresIn = 3600, authToken, } = options;
+    const [files, setFiles] = (0, react_1.useState)([]);
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const reload = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        setLoading(true);
+        setError(null);
+        try {
+            const userFiles = yield (0, fileStorage_1.listUserFiles)(userId, bucket, authToken);
+            let filesWithUrls = userFiles.map((file) => ({
+                name: file.name,
+                id: file.id,
+                created_at: file.created_at,
+                updated_at: file.updated_at,
+            }));
+            // Генерируем signed URLs если нужно
+            if (autoGenerateUrls) {
+                const filesWithSignedUrls = yield Promise.all(filesWithUrls.map((file) => __awaiter(void 0, void 0, void 0, function* () {
+                    const signedUrl = yield (0, fileStorage_1.getSignedUrl)({
+                        path: `${userId}/${file.name}`,
+                        bucket,
+                        expiresIn: urlExpiresIn,
+                        authToken,
+                    });
+                    return Object.assign(Object.assign({}, file), { signedUrl: signedUrl || undefined });
+                })));
+                filesWithUrls = filesWithSignedUrls;
+            }
+            setFiles(filesWithUrls);
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : 'Ошибка загрузки файлов';
+            setError(errorMsg);
+            console.error('Error loading files:', err);
+        }
+        finally {
+            setLoading(false);
+        }
+    }), [userId, bucket, autoGenerateUrls, urlExpiresIn, authToken]);
+    const deleteOne = (0, react_1.useCallback)((fileName) => __awaiter(void 0, void 0, void 0, function* () {
+        const filePath = `${userId}/${fileName}`;
+        const success = yield (0, fileStorage_1.deleteFile)(filePath, bucket, authToken);
+        if (success) {
+            setFiles((prev) => prev.filter((file) => file.name !== fileName));
+        }
+        return success;
+    }), [userId, bucket, authToken]);
+    const deleteMultiple = (0, react_1.useCallback)((fileNames) => __awaiter(void 0, void 0, void 0, function* () {
+        const filePaths = fileNames.map((name) => `${userId}/${name}`);
+        const success = yield (0, fileStorage_1.deleteFiles)(filePaths, bucket, authToken);
+        if (success) {
+            setFiles((prev) => prev.filter((file) => !fileNames.includes(file.name)));
+        }
+        return success;
+    }), [userId, bucket, authToken]);
+    const getFileUrl = (0, react_1.useCallback)((fileName) => __awaiter(void 0, void 0, void 0, function* () {
+        const filePath = `${userId}/${fileName}`;
+        return yield (0, fileStorage_1.getSignedUrl)({
+            path: filePath,
+            bucket,
+            expiresIn: urlExpiresIn,
+            authToken,
+        });
+    }), [userId, bucket, urlExpiresIn, authToken]);
+    (0, react_1.useEffect)(() => {
+        if (autoLoad) {
+            reload();
+        }
+    }, [autoLoad, reload]);
+    return {
+        files,
+        loading,
+        error,
+        reload,
+        deleteOne,
+        deleteMultiple,
+        getFileUrl,
+    };
+};
+exports.useUserFiles = useUserFiles;

package/dist/utils/fileStorage.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Типы для работы с файловым хранилищем
+ */
+export interface UploadFileOptions {
+    file: File | Blob;
+    fileName: string;
+    bucket?: string;
+    userId: string;
+    contentType?: string;
+    cacheControl?: string;
+    upsert?: boolean;
+    authToken?: string;
+}
+export interface UploadFileResult {
+    success: boolean;
+    publicUrl?: string;
+    signedUrl?: string;
+    path?: string;
+    error?: string;
+}
+export interface GetFileUrlOptions {
+    path: string;
+    bucket?: string;
+    expiresIn?: number;
+    authToken?: string;
+}
+/**
+ * Названия бакетов по умолчанию
+ */
+export declare const DEFAULT_BUCKET = "user-files";
+export declare const DOCUMENTS_BUCKET = "documents";
+export declare const IMAGES_BUCKET = "images";
+/**
+ * Загружает файл в Supabase Storage
+ * Файл сохраняется по пути: {userId}/{fileName}
+ *
+ * @param options - параметры загрузки файла
+ * @returns результат загрузки с ссылкой на файл
+ */
+export declare const uploadFile: (options: UploadFileOptions) => Promise<UploadFileResult>;
+/**
+ * Получает подписанный URL для доступа к файлу
+ *
+ * @param options - параметры получения URL
+ * @returns подписанный URL или null при ошибке
+ */
+export declare const getSignedUrl: (options: GetFileUrlOptions) => Promise<string | null>;
+/**
+ * Получает публичный URL для файла
+ *
+ * Для ПРИВАТНЫХ бакетов:
+ * - URL постоянный (не истекает)
+ * - Требует Authorization header с service role key для доступа
+ * - Используется на backend для суперадмина
+ *
+ * Для ПУБЛИЧНЫХ бакетов:
+ * - URL доступен всем без аутентификации
+ *
+ * @example Backend usage for private buckets:
+ * ```typescript
+ * const url = getPublicUrl(filePath, bucket);
+ *
+ * // Access with service role key:
+ * fetch(url, {
+ *   headers: {
+ *     'Authorization': `Bearer ${SUPABASE_SERVICE_ROLE_KEY}`
+ *   }
+ * })
+ * ```
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @returns постоянный URL
+ */
+export declare const getPublicUrl: (path: string, bucket?: string) => string | null;
+/**
+ * Удаляет файл из хранилища
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns true при успешном удалении
+ */
+export declare const deleteFile: (path: string, bucket?: string, authToken?: string) => Promise<boolean>;
+/**
+ * Удаляет несколько файлов из хранилища
+ *
+ * @param paths - массив путей к файлам
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns true при успешном удалении всех файлов
+ */
+export declare const deleteFiles: (paths: string[], bucket?: string, authToken?: string) => Promise<boolean>;
+/**
+ * Получает список файлов пользователя
+ *
+ * @param userId - ID пользователя
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns список файлов или пустой массив при ошибке
+ */
+export declare const listUserFiles: (userId: string, bucket?: string, authToken?: string) => Promise<import("@supabase/storage-js").FileObject[]>;
+/**
+ * Скачивает файл из хранилища
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns Blob файла или null при ошибке
+ */
+export declare const downloadFile: (path: string, bucket?: string, authToken?: string) => Promise<Blob | null>;

package/dist/utils/fileStorage.js

@@ -0,0 +1,342 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.downloadFile = exports.listUserFiles = exports.deleteFiles = exports.deleteFile = exports.getPublicUrl = exports.getSignedUrl = exports.uploadFile = exports.IMAGES_BUCKET = exports.DOCUMENTS_BUCKET = exports.DEFAULT_BUCKET = void 0;
+const supabase_1 = require("./supabase");
+/**
+ * Названия бакетов по умолчанию
+ */
+exports.DEFAULT_BUCKET = 'user-files';
+exports.DOCUMENTS_BUCKET = 'documents';
+exports.IMAGES_BUCKET = 'images';
+/**
+ * Загружает файл в Supabase Storage
+ * Файл сохраняется по пути: {userId}/{fileName}
+ *
+ * @param options - параметры загрузки файла
+ * @returns результат загрузки с ссылкой на файл
+ */
+const uploadFile = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { file, fileName, bucket = exports.DEFAULT_BUCKET, userId, contentType, cacheControl = '3600', upsert = false, authToken, } = options;
+    if (!supabase_1.supabaseClient) {
+        return {
+            success: false,
+            error: 'Supabase client is not initialized',
+        };
+    }
+    try {
+        // Если передан authToken, создаем клиент с токеном
+        let client = supabase_1.supabaseClient;
+        if (authToken) {
+            const { createClient } = yield Promise.resolve().then(() => __importStar(require('@supabase/supabase-js')));
+            client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PUBLIC_KEY, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                },
+            });
+        }
+        // Путь к файлу: userId/fileName
+        const filePath = `${userId}/${fileName}`;
+        const { data, error } = yield client.storage.from(bucket).upload(filePath, file, {
+            contentType,
+            cacheControl,
+            upsert,
+        });
+        if (error) {
+            console.error('Error uploading file:', error);
+            return {
+                success: false,
+                error: error.message,
+            };
+        }
+        // Получаем публичный URL
+        const { data: urlData } = client.storage.from(bucket).getPublicUrl(data.path);
+        // Получаем подписанный URL (действителен 1 час по умолчанию)
+        const { data: signedUrlData, error: signedUrlError } = yield client.storage
+            .from(bucket)
+            .createSignedUrl(data.path, 3600);
+        return {
+            success: true,
+            publicUrl: urlData.publicUrl,
+            signedUrl: signedUrlError ? undefined : signedUrlData.signedUrl,
+            path: data.path,
+        };
+    }
+    catch (error) {
+        console.error('Unexpected error uploading file:', error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+});
+exports.uploadFile = uploadFile;
+/**
+ * Получает подписанный URL для доступа к файлу
+ *
+ * @param options - параметры получения URL
+ * @returns подписанный URL или null при ошибке
+ */
+const getSignedUrl = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { path, bucket = exports.DEFAULT_BUCKET, expiresIn = 3600, authToken } = options;
+    if (!supabase_1.supabaseClient) {
+        console.error('Supabase client is not initialized');
+        return null;
+    }
+    try {
+        // Если передан authToken, создаем клиент с токеном
+        let client = supabase_1.supabaseClient;
+        if (authToken) {
+            const { createClient } = yield Promise.resolve().then(() => __importStar(require('@supabase/supabase-js')));
+            client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PUBLIC_KEY, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                },
+            });
+        }
+        const { data, error } = yield client.storage.from(bucket).createSignedUrl(path, expiresIn);
+        if (error) {
+            console.error('Error creating signed URL:', error);
+            return null;
+        }
+        return data.signedUrl;
+    }
+    catch (error) {
+        console.error('Unexpected error creating signed URL:', error);
+        return null;
+    }
+});
+exports.getSignedUrl = getSignedUrl;
+/**
+ * Получает публичный URL для файла
+ *
+ * Для ПРИВАТНЫХ бакетов:
+ * - URL постоянный (не истекает)
+ * - Требует Authorization header с service role key для доступа
+ * - Используется на backend для суперадмина
+ *
+ * Для ПУБЛИЧНЫХ бакетов:
+ * - URL доступен всем без аутентификации
+ *
+ * @example Backend usage for private buckets:
+ * ```typescript
+ * const url = getPublicUrl(filePath, bucket);
+ *
+ * // Access with service role key:
+ * fetch(url, {
+ *   headers: {
+ *     'Authorization': `Bearer ${SUPABASE_SERVICE_ROLE_KEY}`
+ *   }
+ * })
+ * ```
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @returns постоянный URL
+ */
+const getPublicUrl = (path, bucket = exports.DEFAULT_BUCKET) => {
+    if (!supabase_1.supabaseClient) {
+        console.error('Supabase client is not initialized');
+        return null;
+    }
+    const { data } = supabase_1.supabaseClient.storage.from(bucket).getPublicUrl(path);
+    return data.publicUrl;
+};
+exports.getPublicUrl = getPublicUrl;
+/**
+ * Удаляет файл из хранилища
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns true при успешном удалении
+ */
+const deleteFile = (path_1, ...args_1) => __awaiter(void 0, [path_1, ...args_1], void 0, function* (path, bucket = exports.DEFAULT_BUCKET, authToken) {
+    if (!supabase_1.supabaseClient) {
+        console.error('Supabase client is not initialized');
+        return false;
+    }
+    try {
+        let client = supabase_1.supabaseClient;
+        if (authToken) {
+            const { createClient } = yield Promise.resolve().then(() => __importStar(require('@supabase/supabase-js')));
+            client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PUBLIC_KEY, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                },
+            });
+        }
+        const { error } = yield client.storage.from(bucket).remove([path]);
+        if (error) {
+            console.error('Error deleting file:', error);
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Unexpected error deleting file:', error);
+        return false;
+    }
+});
+exports.deleteFile = deleteFile;
+/**
+ * Удаляет несколько файлов из хранилища
+ *
+ * @param paths - массив путей к файлам
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns true при успешном удалении всех файлов
+ */
+const deleteFiles = (paths_1, ...args_1) => __awaiter(void 0, [paths_1, ...args_1], void 0, function* (paths, bucket = exports.DEFAULT_BUCKET, authToken) {
+    if (!supabase_1.supabaseClient) {
+        console.error('Supabase client is not initialized');
+        return false;
+    }
+    try {
+        let client = supabase_1.supabaseClient;
+        if (authToken) {
+            const { createClient } = yield Promise.resolve().then(() => __importStar(require('@supabase/supabase-js')));
+            client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PUBLIC_KEY, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                },
+            });
+        }
+        const { error } = yield client.storage.from(bucket).remove(paths);
+        if (error) {
+            console.error('Error deleting files:', error);
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Unexpected error deleting files:', error);
+        return false;
+    }
+});
+exports.deleteFiles = deleteFiles;
+/**
+ * Получает список файлов пользователя
+ *
+ * @param userId - ID пользователя
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns список файлов или пустой массив при ошибке
+ */
+const listUserFiles = (userId_1, ...args_1) => __awaiter(void 0, [userId_1, ...args_1], void 0, function* (userId, bucket = exports.DEFAULT_BUCKET, authToken) {
+    if (!supabase_1.supabaseClient) {
+        console.error('Supabase client is not initialized');
+        return [];
+    }
+    try {
+        let client = supabase_1.supabaseClient;
+        if (authToken) {
+            const { createClient } = yield Promise.resolve().then(() => __importStar(require('@supabase/supabase-js')));
+            client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PUBLIC_KEY, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                },
+            });
+        }
+        const { data, error } = yield client.storage.from(bucket).list(userId);
+        if (error) {
+            console.error('Error listing files:', error);
+            return [];
+        }
+        return data || [];
+    }
+    catch (error) {
+        console.error('Unexpected error listing files:', error);
+        return [];
+    }
+});
+exports.listUserFiles = listUserFiles;
+/**
+ * Скачивает файл из хранилища
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns Blob файла или null при ошибке
+ */
+const downloadFile = (path_1, ...args_1) => __awaiter(void 0, [path_1, ...args_1], void 0, function* (path, bucket = exports.DEFAULT_BUCKET, authToken) {
+    if (!supabase_1.supabaseClient) {
+        console.error('Supabase client is not initialized');
+        return null;
+    }
+    try {
+        let client = supabase_1.supabaseClient;
+        if (authToken) {
+            const { createClient } = yield Promise.resolve().then(() => __importStar(require('@supabase/supabase-js')));
+            client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PUBLIC_KEY, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                },
+            });
+        }
+        const { data, error } = yield client.storage.from(bucket).download(path);
+        if (error) {
+            console.error('Error downloading file:', error);
+            return null;
+        }
+        return data;
+    }
+    catch (error) {
+        console.error('Unexpected error downloading file:', error);
+        return null;
+    }
+});
+exports.downloadFile = downloadFile;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squarefi-bff-api-module",
-  "version": "1.28.0",
+  "version": "1.29.1",
   "description": "Squarefi BFF API client module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -41,7 +41,6 @@
     "husky": "^9.1.7",
     "jest": "^29.x.x",
     "openapi-typescript": "^7.8.0",
-    "prettier": "^3.6.2",
     "ts-jest": "^29.x.x",
     "ts-node": "^10.9.2",
     "typescript": "^5.x.x"

package/src/api/orders.ts

@@ -70,6 +70,13 @@ export const orders = {
           { data },
         ),
 
+      [OrderType.EXCHANGE_OMNI]: (
+        data: API.Orders.Create.ByOrderType.EXCHANGE_OMNI.Request,
+      ): Promise<API.Orders.Create.ByOrderType.EXCHANGE_OMNI.Response> =>
+        apiClientV1.postRequest<API.Orders.Create.ByOrderType.EXCHANGE_OMNI.Response>('/orders/EXCHANGE_OMNI', {
+          data,
+        }),
+
       [OrderType.WITHDRAW_CARD_PREPAID]: (
         data: API.Orders.Create.ByOrderType.WITHDRAW_CARD_PREPAID.Request,
       ): Promise<API.Orders.Create.ByOrderType.WITHDRAW_CARD_PREPAID.Response> =>

package/src/api/types/autogen/apiV2.types.ts

@@ -1772,6 +1772,7 @@ export interface components {
             usd_value_of_crypto?: string | null;
             usd_value_of_fiat?: string | null;
             occupation?: string | null;
+            occupation_other?: string | null;
             /**
              * @default UNVERIFIED
              * @enum {string}
@@ -1875,6 +1876,7 @@ export interface components {
             usd_value_of_crypto?: string | null;
             usd_value_of_fiat?: string | null;
             occupation?: string | null;
+            occupation_other?: string | null;
             /** @enum {string|null} */
             employment_status?: "EMPLOYEE" | "SELF_EMPLOYED" | "RETIRED" | "UNEMPLOYED" | "OTHER" | null;
             employment_description?: string | null;

package/src/api/types/types.ts

@@ -1417,6 +1417,39 @@ export namespace API {
           };
         }
 
+        export namespace EXCHANGE_OMNI {
+          export type Request = {
+            amount: number;
+            wallet_uuid: string;
+            from_uuid: string;
+            to_uuid: string;
+          };
+          export type Response = {
+            created_at: string;
+            order_uuid: string;
+            wallet_uuid: string;
+            from_uuid: string;
+            to_uuid: string;
+            amount_from: number;
+            order_type: 'EXCHANGE_OMNI';
+            status: OrderStatuses;
+            amount_to: number;
+            info: string;
+            meta: {
+              fee: number;
+              order_uuid: string;
+              to_address: string;
+              fee_currency: string;
+              billing_amount: number;
+              transaction_amount: number;
+              billing_amount_currency: string;
+              transaction_amount_currency: string;
+              network_fee: number;
+            };
+            id: string;
+          };
+        }
+
         export namespace TRANSFER_CARD_WHOLESALE {
           export type Request = {
             amount: number;
@@ -2130,7 +2163,7 @@ export namespace API {
       }
 
       export namespace DepositInstruction {
-        export type InstructionType = 'ACH' | 'FEDWIRE' | 'SWIFT';
+        export type InstructionType = 'ACH' | 'FEDWIRE' | 'SWIFT' | 'SEPA_CT';
 
         export interface Address {
           city: string;
@@ -2170,6 +2203,13 @@ export namespace API {
           institution_address: Address;
           account_holder_address: Address;
         }
+        export interface SEPA extends Common {
+          instruction_type: 'SEPA_CT';
+          iban: string;
+          swift_bic: string;
+          institution_address: Address;
+          account_holder_address: Address;
+        }
 
         export type DepositInstruction = ACH | FEDWIRE | SWIFT | Common;
       }

package/src/constants.ts

@@ -67,6 +67,7 @@ export enum OrderType {
   DEPOSIT_FIAT_SEPA = 'DEPOSIT_FIAT_SEPA',
   DEPOSIT_FIAT_SWIFT = 'DEPOSIT_FIAT_SWIFT',
   EXCHANGE_CRYPTO_INTERNAL = 'EXCHANGE_CRYPTO_INTERNAL',
+  EXCHANGE_OMNI = 'EXCHANGE_OMNI',
   TRANSFER_CARD_PREPAID = 'TRANSFER_CARD_PREPAID',
   CARD_ISSUING_FEE = 'CARD_ISSUING_FEE',
   TRANSFER_CARD_SUBACCOUNT = 'TRANSFER_CARD_SUBACCOUNT',
@@ -107,6 +108,7 @@ export enum WalletTransactionRecordType {
   DEPOSIT_INTERNAL = 'DEPOSIT_INTERNAL',
   DEPOSIT_MANUAL = 'DEPOSIT_MANUAL',
   EXCHANGE_CRYPTO_INTERNAL = 'EXCHANGE_CRYPTO_INTERNAL',
+  EXCHANGE_OMNI = 'EXCHANGE_OMNI',
   EXT_EXCHANGE = 'EXT_EXCHANGE',
   FEE = 'FEE',
   HIFI_ACH_OFFRAMP = 'HIFI_ACH_OFFRAMP',