src/api/client.ts - master - sourex/CFA

src/api/client.ts
154 строки5 KB
unknown
Initial commit: DAP Platform with assets, portfolio and history
23 фев 2026, 17:31
23 фев 2026, 17:314461970
import axios from 'axios';
import { MOCK_ASSETS, MOCK_PORTFOLIO, MOCK_TRANSACTIONS } from './mocks/assets';
import {
    Asset,
    PortfolioItem,
    Transaction,
    ApiResponse,
    BuyAssetRequest,
    BuyAssetResponse,
    PortfolioResponse,
    ErrorResponse
} from '../types/api';

const API_BASE_URL = process.env.REACT_APP_API_URL || 'http://localhost:3001/api/v1';

const apiClient = axios.create({
    baseURL: API_BASE_URL,
    headers: {
        'Content-Type': 'application/json',
    },
});

const USE_MOCKS = true;
const mockDelay = (ms: number = 500) => new Promise(resolve => setTimeout(resolve, ms));

export const api = {
    getAssets: async (params?: { status?: string; minApy?: number; limit?: number; offset?: number }): Promise<ApiResponse<Asset>> => {
        if (USE_MOCKS) {
            await mockDelay();

            let filtered = [...MOCK_ASSETS];

            if (params?.status) {
                filtered = filtered.filter(a => a.status === params.status);
            }
            if (params?.minApy) {
                filtered = filtered.filter(a => a.apy >= (params.minApy || 0));
            }

            const limit = params?.limit || 20;
            const offset = params?.offset || 0;

            return {
                items: filtered.slice(offset, offset + limit),
                total: filtered.length,
                limit,
                offset
            };
        }

        const response = await apiClient.get('/assets', { params });
        return response.data;
    },

    getAssetById: async (assetId: string): Promise<Asset> => {
        if (USE_MOCKS) {
            await mockDelay();
            const asset = MOCK_ASSETS.find(a => a.id === assetId);
            if (!asset) {
                throw {
                    code: 404,
                    message: 'Asset not found'
                };
            }
            return asset;
        }
        const response = await apiClient.get(`/assets/${assetId}`);
        return response.data;
    },

    getPortfolio: async (walletAddress: string): Promise<PortfolioResponse> => {
        if (USE_MOCKS) {
            await mockDelay();
            return {
                totalValue: MOCK_PORTFOLIO.reduce((sum, item) => sum + parseFloat(item.currentValue), 0).toString(),
                items: MOCK_PORTFOLIO
            };
        }
        const response = await apiClient.get(`/portfolio/${walletAddress}`);
        return response.data;
    },

    getTransactions: async (walletAddress: string, limit?: number): Promise<{ items: Transaction[] }> => {
        if (USE_MOCKS) {
            await mockDelay();
            return {
                items: MOCK_TRANSACTIONS.slice(0, limit || 50)
            };
        }
        const response = await apiClient.get('/transactions', { params: { walletAddress, limit } });
        return response.data;
    },

    buyAsset: async (assetId: string, data: BuyAssetRequest): Promise<BuyAssetResponse> => {
        if (USE_MOCKS) {
            await mockDelay(1000);

            if (parseFloat(data.amount) < 100) {
                throw {
                    code: 400,
                    message: 'Amount is less than minimum investment',
                    details: 'Minimum investment is 100 USDC'
                };
            }

            const asset = MOCK_ASSETS.find(a => a.id === assetId);

            const newTransaction: Transaction = {
                id: `tx_${Date.now()}`,
                type: 'BUY',
                assetName: asset?.name || 'Unknown Asset',
                amount: data.amount,
                price: '1.00',
                total: data.amount,
                timestamp: new Date().toISOString(),
                status: 'SUCCESS',
                txHash: `0x${Math.random().toString(16).substring(2)}${Math.random().toString(16).substring(2)}`
            };

            MOCK_TRANSACTIONS.unshift(newTransaction);

            return {
                transactionId: `mock_tx_${Date.now()}`,
                txHash: newTransaction.txHash,
                status: 'SUCCESS',
                estimatedGas: '21000'
            };
        }
        const response = await apiClient.post(`/assets/${assetId}/buy`, data);
        return response.data;
    },

    searchAssets: async (query: string): Promise<Asset[]> => {
        if (USE_MOCKS) {
            await mockDelay();
            const lowerQuery = query.toLowerCase();
            return MOCK_ASSETS.filter(asset =>
                asset.name.toLowerCase().includes(lowerQuery) ||
                asset.description.toLowerCase().includes(lowerQuery)
            );
        }
        const response = await apiClient.get('/assets/search', { params: { q: query } });
        return response.data;
    },

    getTransactionByHash: async (txHash: string): Promise<Transaction | null> => {
        if (USE_MOCKS) {
            await mockDelay();
            return MOCK_TRANSACTIONS.find(tx => tx.txHash === txHash) || null;
        }
        const response = await apiClient.get(`/transactions/${txHash}`);
        return response.data;
    }
};