nexushub-commands 1.0.0

package/lib/Client.d.ts

@@ -0,0 +1,20 @@
+import { AxiosInstance } from 'axios';
+import { Evogram } from 'evogram';
+import { CommandContext } from 'evogram/lib/migrated';
+export interface DepositConfig {
+    API: AxiosInstance;
+    currency: string;
+    images: {
+        deposit: string;
+        depositCard: string;
+        depositCrypto: string;
+        [key: string]: string;
+    };
+    support: {
+        username: string;
+    };
+}
+export declare class Client {
+    static config: (context: CommandContext) => DepositConfig;
+    static init(client: Evogram): Promise<void>;
+}

package/lib/Client.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const Deposit_command_1 = require("./commands/Deposit.command");
+const GetDepositOrder_command_1 = require("./commands/GetDepositOrder.command");
+// Значения по умолчанию для конфигурации
+const defaultConfig = {
+    API: axios_1.default.create(),
+    currency: 'RUB',
+    images: {
+        deposit: 'deposit',
+        depositCard: 'deposit-card',
+        depositCrypto: 'deposit-crypto',
+    },
+    support: {
+        username: 'support',
+    },
+};
+class Client {
+    static init(client) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            client.commands.commands.push(new Deposit_command_1.DepositCommand(client), new GetDepositOrder_command_1.GetDepositOrderCommand(client));
+        });
+    }
+}
+exports.Client = Client;

package/lib/commands/CheckPaidOrder.command.d.ts

@@ -0,0 +1,4 @@
+import { Command, CommandContext } from 'evogram/lib/migrated';
+export declare class CheckPaidOrderCommand extends Command {
+    execute(context: CommandContext, orderId: string): Promise<void>;
+}

package/lib/commands/CheckPaidOrder.command.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckPaidOrderCommand = void 0;
+const tslib_1 = require("tslib");
+const evogram_1 = require("evogram");
+const migrated_1 = require("evogram/lib/migrated");
+const Client_1 = require("../Client");
+let CheckPaidOrderCommand = class CheckPaidOrderCommand extends migrated_1.Command {
+    execute(context, orderId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const config = Client_1.Client.config(context);
+            yield config.API.get(`/orders/${orderId}/checkPaid`).catch(() => { });
+            const order = yield config.API.get(`/orders/${orderId}`);
+            if (order.data.status !== 'paid' && order.data.status !== 'fakepaid')
+                throw new Error('Счет еще не оплачен');
+            else
+                (_a = context.callbackQuery) === null || _a === void 0 ? void 0 : _a.answer({ text: 'Счет оплачен', show_alert: true });
+        });
+    }
+};
+exports.CheckPaidOrderCommand = CheckPaidOrderCommand;
+tslib_1.__decorate([
+    tslib_1.__param(1, (0, evogram_1.CommandArgument)('orderId')),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [migrated_1.CommandContext, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], CheckPaidOrderCommand.prototype, "execute", null);
+exports.CheckPaidOrderCommand = CheckPaidOrderCommand = tslib_1.__decorate([
+    (0, evogram_1.CommandD)({ name: 'checkPaidOrder', backButton: 'К пополнению' })
+], CheckPaidOrderCommand);

package/lib/commands/Deposit.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'evogram';
+import { CommandContext } from 'evogram/lib/migrated';
+export declare class DepositCommand extends Command {
+    execute(context: CommandContext, method: string, coin: string | undefined, deposit: number): Promise<any>;
+}

package/lib/commands/Deposit.command.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DepositCommand = void 0;
+const tslib_1 = require("tslib");
+const evogram_1 = require("evogram");
+const migrated_1 = require("evogram/lib/migrated");
+const Client_1 = require("../Client");
+const GetDepositOrder_command_1 = require("./GetDepositOrder.command");
+const formatMessage_1 = require("../utils/formatMessage");
+let DepositCommand = class DepositCommand extends evogram_1.Command {
+    execute(context, method, coin, deposit) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const config = Client_1.Client.config(context);
+            let interval;
+            if (method !== 'cryptoWallet') {
+                if (['card', 'qrcode'].includes(method)) {
+                    const message = yield context.sendFormatted({
+                        photo: config.images.deposit,
+                        body: [
+                            {
+                                title: 'ℹ️ Подождите, идет обработка заявки',
+                                data: [['Создаем заявку на пополнение...']],
+                            },
+                        ],
+                    });
+                    const startTime = Date.now();
+                    interval = setInterval(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        yield message.edit({
+                            text: (0, formatMessage_1.formatMessage)({
+                                body: [
+                                    {
+                                        title: 'ℹ️ Подождите, идет обработка заявки',
+                                        data: [[`Создаем заявку на пополнение...`]],
+                                    },
+                                ],
+                                footer: `<i>⏳ Прошло {{ ${Math.floor((Date.now() - startTime) / 1000)} }} сек.</i>`,
+                            }),
+                            parse_mode: 'HTML',
+                        });
+                    }), 1000);
+                }
+                const order = yield config.API.post(`orders`, {
+                    mirrorId: context.mammoth.mirror.mirror.id,
+                    mammothId: context.user.id,
+                    method,
+                    amount: Number(deposit),
+                    currency: config.currency,
+                })
+                    .then((x) => x.data)
+                    .catch(() => null);
+                //@ts-ignore
+                if (interval)
+                    clearInterval(interval);
+                this.logger.log(`Запрос на пополнение: ${JSON.stringify(order, null, 2)}`);
+                if (!order) {
+                    context.user.log(0, `Не удалось получить реквизиты для пополнения на сумму ${Number(deposit).toLocaleString('ru')} ${config.currency}`);
+                    return context.sendFormatted({
+                        photo: config.images.deposit,
+                        header: '<b>❗️К сожалению, сейчас нет доступных реквизитов для оплаты.</b>',
+                        footer: '<i>ℹ️ Вы можете попробовать чуть позже, либо связаться с технической поддержкой.</i>',
+                    }, {
+                        reply_markup: {
+                            inline_keyboard: [[{ text: '👩‍💻 Поддержка', url: `t.me/${config.support.username}` }]],
+                        },
+                    });
+                }
+                if (!order.isRepeat)
+                    yield context.user.log(0, `Запросил пополнение на ${Number(order.amount).toLocaleString('ru')} ${order.currency} (${yield order.amount.convert({
+                        from: order.currency,
+                        to: 'RUB',
+                        ceiled: true,
+                    })})`, {
+                        keyboard: [[{ text: '🚀 Оплатить счет', callback_data: `paidOrder?orderId=${order.id}` }]],
+                    });
+                return context.redirect(GetDepositOrder_command_1.GetDepositOrderCommand, { orderId: order.id });
+            }
+            else {
+                const wallets = (yield config.API.get('/crypto/wallets')).data.filter((x) => x.isActive);
+                return context.sendFormatted({
+                    photo: config.images.depositCrypto,
+                    header: '<b>Создана заявка на оплату</b>',
+                    body: [
+                        {
+                            title: 'ℹ️ Информация о реквизитах',
+                            data: [
+                                ['Адрес кошелька', `{{ ${wallets.find((x) => x.name === coin).address} }}`],
+                                ['Криптовалюта', `{{ ${coin} }}`],
+                            ],
+                        },
+                    ],
+                    footer: '<i>Это Ваш постоянный адрес для пополнения.</i>',
+                });
+            }
+        });
+    }
+};
+exports.DepositCommand = DepositCommand;
+tslib_1.__decorate([
+    tslib_1.__param(1, (0, evogram_1.CommandArgument)('method', (_a) => tslib_1.__awaiter(void 0, [_a], void 0, function* ({ value, context }) {
+        const config = Client_1.Client.config(context);
+        if (value) {
+            const paymentMethods = (yield config.API.get('/payments')).data;
+            if (!paymentMethods.find((x) => x.isEnabled && x.type.toLowerCase() === value.toLowerCase()))
+                throw new Error('К сожалению, данный метод пополнения временно недоступен');
+            if (value !== 'cryptowallet')
+                return value;
+        }
+        if (!value) {
+            const allowedMethods = (yield config.API.get('/orders/allowedMethods', { params: { currency: config.currency } })).data;
+            yield context.sendFormatted({
+                photo: config.images.deposit,
+                header: '<b>📤 Выберите удобный для Вас метод пополнения.</b>',
+            }, {
+                reply_markup: {
+                    inline_keyboard: [
+                        ...(allowedMethods.includes('card') ? [[{ text: '💳 Банковская карта', command: DepositCommand, payload: { method: 'card' } }]] : []),
+                        ...(allowedMethods.includes('qrcode') ? [[{ text: '📸 QR-код (СБП)', command: DepositCommand, payload: { method: 'qrcode' } }]] : []),
+                        [{ text: '🪙 Криптовалюта', command: DepositCommand, payload: { method: 'cryptowallet' } }],
+                    ],
+                },
+            });
+        }
+        else if (value === 'cryptowallet') {
+            yield context.sendFormatted({
+                photo: config.images.depositCrypto,
+                header: '<b>🪙 Выберите удобный для вас метод пополнения.</b>',
+            }, {
+                reply_markup: {
+                    inline_keyboard: [
+                        [
+                            { text: '🤖 CryptoBot', command: DepositCommand, payload: { method: 'cryptoBot' } },
+                            { text: '🌐 По кошельку', command: DepositCommand, payload: { method: 'cryptoWallet' } },
+                        ],
+                    ],
+                },
+            });
+        }
+    }))),
+    tslib_1.__param(2, (0, evogram_1.CommandArgument)('coin', (_a) => tslib_1.__awaiter(void 0, [_a], void 0, function* ({ value, args, context }) {
+        if (value)
+            return value;
+        else if (args.method !== 'cryptoWallet')
+            return true;
+        const config = Client_1.Client.config(context);
+        const wallets = yield config.API.get('/crypto/wallets').then((x) => x.data.filter((x) => x.isActive));
+        context.sendFormatted({
+            header: '<b>🪙 Доступные криптовалюты для пополнения:</b>',
+            photo: config.images.depositCrypto,
+        }, {
+            reply_markup: {
+                inline_keyboard: wallets.map((x) => [
+                    {
+                        text: x.name,
+                        command: DepositCommand,
+                        payload: Object.assign(Object.assign({}, args), { coin: x.name }),
+                    },
+                ]),
+            },
+        });
+    }))),
+    tslib_1.__param(3, (0, evogram_1.CommandArgument)({
+        name: 'deposit',
+        question: (_a) => tslib_1.__awaiter(void 0, [_a], void 0, function* ({ context, error, args, validateArgs }) {
+            var _b;
+            if (args.method === 'cryptoWallet')
+                return 1;
+            const config = Client_1.Client.config(context);
+            let minAmountSetting = JSON.parse(context.state.settings.find((x) => x.name === 'minDeposit').value);
+            let minAmount = (_b = minAmountSetting[config.currency]) !== null && _b !== void 0 ? _b : (yield minAmountSetting['RUB'].convert({ from: 'RUB', to: config.currency }));
+            const minDepositByMethod = yield config.API.get('/config/minDepositByMethod').then((x) => x.data);
+            // prettier-ignore
+            if (minDepositByMethod && minDepositByMethod[args.method] !== undefined && (yield minAmount.convert({ from: config.currency, to: 'RUB' })) < minDepositByMethod[args.method])
+                minAmount = yield minDepositByMethod[args.method].convert({ from: 'RUB', to: config.currency });
+            validateArgs.minAmount = minAmount;
+            return (yield context.sendFormattedQuestion({
+                photo: ['card', 'qrcode'].includes(args.method) ? config.images.deposit : config.images.depositCrypto,
+                body: [
+                    {
+                        title: '💰 Сумма пополнения',
+                        data: [['Введите сумму пополнения']],
+                    },
+                ],
+                footer: `<i>Минимальная сумма пополнения: {{ ${Number(minAmount).toLocaleString('ru')} ${config.currency} }}</i>`,
+                error: error === null || error === void 0 ? void 0 : error.message,
+            })).text;
+        }),
+    }, (0, evogram_1.numberValidator)({ allowFloat: true, min: 0 }), (_a) => tslib_1.__awaiter(void 0, [_a], void 0, function* ({ value, context, args }) {
+        if (args.method === 'cryptoWallet')
+            return 0;
+        const config = Client_1.Client.config(context);
+        const maxDeposit = yield config.API.get('/config/maxDepositInService').then((x) => x.data);
+        const depositAmount = yield value.convert({ from: config.currency, to: 'RUB' });
+        if (depositAmount > maxDeposit)
+            throw new Error(`Пополнение, более чем на ${yield maxDeposit.convert({ from: 'RUB', to: config.currency })}, доступно только через <a href="t.me/{{ ${config.support.username} }}">тех. поддержку</a>`);
+        return value;
+    }), (_a) => tslib_1.__awaiter(void 0, [_a], void 0, function* ({ value, context, validateArgs }) {
+        const config = Client_1.Client.config(context);
+        if (Number(value) < Number(validateArgs.minAmount))
+            throw new Error(`Минимальная сумма пополнения: ${Number(validateArgs.minAmount).toLocaleString('ru')} ${config.currency}`);
+        return value;
+    }))),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [migrated_1.CommandContext, String, Object, Number]),
+    tslib_1.__metadata("design:returntype", Promise)
+], DepositCommand.prototype, "execute", null);
+exports.DepositCommand = DepositCommand = tslib_1.__decorate([
+    (0, evogram_1.CommandD)({ name: 'deposit', description: [{ text: 'Пополнение' }, { language: 'en', text: 'Deposit' }] })
+], DepositCommand);

package/lib/commands/GetDepositOrder.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'evogram';
+import { CommandContext } from 'evogram/lib/migrated';
+export declare class GetDepositOrderCommand extends Command {
+    execute(context: CommandContext, orderId: string): Promise<any>;
+}

package/lib/commands/GetDepositOrder.command.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetDepositOrderCommand = void 0;
+const tslib_1 = require("tslib");
+const evogram_1 = require("evogram");
+const migrated_1 = require("evogram/lib/migrated");
+const Client_1 = require("../Client");
+const CheckPaidOrder_command_1 = require("./CheckPaidOrder.command");
+let GetDepositOrderCommand = class GetDepositOrderCommand extends evogram_1.Command {
+    execute(context, orderId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const config = Client_1.Client.config(context);
+            const order = yield config.API.get(`/orders/deposit/${orderId}`)
+                .then((x) => x.data)
+                .catch(() => null);
+            if (!order)
+                throw new Error('Заявка на оплату не найдена');
+            switch (order.method) {
+                case 'cryptoBot':
+                    return context.sendFormatted({
+                        photo: config.images.depositCrypto,
+                        header: '<b>Создана заявка на оплату</b>',
+                        body: [
+                            {
+                                title: 'ℹ️ Информация о счете',
+                                data: [
+                                    ['Сумма', `{{ ${Number(order.amount).toLocaleString('ru')} ${order.currency} }}`],
+                                    ['Дата', `{{ ${new Date().toLocaleString('ru')} }}`],
+                                ],
+                            },
+                            {
+                                title: '📎 Ваша ссылка для оплаты',
+                                data: [[`{{ ${order.cryptoBot.url} }}`]],
+                            },
+                        ],
+                        footer: '<i>Ссылка действительна 10 минут.</i>',
+                    }, {
+                        reply_markup: {
+                            inline_keyboard: [
+                                [{ text: '🔗 Перейти к оплате', url: order.cryptoBot.url }],
+                                [{ text: '🔄 Проверить оплату', command: CheckPaidOrder_command_1.CheckPaidOrderCommand, payload: { orderId: order.id } }],
+                            ],
+                        },
+                    });
+                case 'card':
+                    return context.sendFormatted({
+                        photo: config.images.deposit,
+                        header: order.isRepeat ? '<b>❗️У вас уже есть заявка на пополнение, сначала оплатите ёё</b>' : '<b>Создана заявка на оплату</b>',
+                        body: [
+                            {
+                                title: 'ℹ️ Информация о реквизитах',
+                                data: [
+                                    ['Реквизиты', `{{ ${order.card.requisites} }}`],
+                                    order.card.bank && ['Банк', `{{ ${order.card.bank} }}`],
+                                    order.card.holder && ['Получатель', `{{ ${order.card.holder} }}`],
+                                    ['Сумма оплаты', `{{ ${Number(order.amount).toLocaleString('ru')} ${order.currency} }}`],
+                                ],
+                            },
+                        ],
+                        footer: '<i>Реквизиты действительны 10 минут.</i>',
+                    }, {
+                        reply_markup: {
+                            inline_keyboard: [[{ text: '🔄 Проверить оплату', command: CheckPaidOrder_command_1.CheckPaidOrderCommand, payload: { orderId: order.id } }]],
+                        },
+                    });
+                case 'qrcode':
+                    return context.sendFormatted({
+                        photo: config.images.deposit,
+                        header: '<b>Создана заявка на оплату</b>',
+                        footer: `<i>Ссылка действительна ${Math.ceil((new Date(order.expiresAt).getTime() - new Date().getTime()) / 60000)} минут.</i>`,
+                    }, {
+                        reply_markup: {
+                            inline_keyboard: [
+                                [{ text: '🔗 Перейти к оплате', url: order.qrcode.link }],
+                                [{ text: '🔄 Проверить оплату', command: CheckPaidOrder_command_1.CheckPaidOrderCommand, payload: { orderId: order.id } }],
+                            ],
+                        },
+                    });
+            }
+        });
+    }
+};
+exports.GetDepositOrderCommand = GetDepositOrderCommand;
+tslib_1.__decorate([
+    tslib_1.__param(1, (0, evogram_1.CommandArgument)('orderId')),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [migrated_1.CommandContext, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], GetDepositOrderCommand.prototype, "execute", null);
+exports.GetDepositOrderCommand = GetDepositOrderCommand = tslib_1.__decorate([
+    (0, evogram_1.CommandD)({ name: 'getDepositOrder', backButton: 'К пополнению' })
+], GetDepositOrderCommand);

package/lib/commands/Withdrawal.command.js

@@ -0,0 +1 @@
+"use strict";

package/lib/commands/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Deposit.command';
+export * from './GetDepositOrder.command';
+export * from './CheckPaidOrder.command';

package/lib/commands/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./Deposit.command"), exports);
+tslib_1.__exportStar(require("./GetDepositOrder.command"), exports);
+tslib_1.__exportStar(require("./CheckPaidOrder.command"), exports);

package/lib/convert.d.ts

@@ -0,0 +1,17 @@
+interface ConvertParams {
+    from?: string;
+    to: string;
+    round?: boolean;
+    ceiled?: boolean;
+}
+interface CurrencyConverter {
+    convert(params: ConvertParams): Promise<number>;
+}
+declare global {
+    interface String extends CurrencyConverter {
+        translate(language: string, ...args: any[]): Promise<string>;
+    }
+    interface Number extends CurrencyConverter {
+    }
+}
+export {};

package/lib/convert.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const CoinBase_service_1 = require("./utils/CoinBase.service");
+class ConvertedNumber {
+    constructor(value, stringValue) {
+        this.value = value;
+        this.stringValue = stringValue;
+    }
+    // Переопределяем метод toString
+    toString() {
+        return this.stringValue;
+    }
+    // Добавляем valueOf для корректного сравнения
+    valueOf() {
+        return this.value;
+    }
+    convert(params) {
+        return this.value.convert(params);
+    }
+}
+Number.prototype.convert = function (params) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const { to = 'RUB', from = 'RUB', round, ceiled } = params;
+        const fromCurrency = from.toUpperCase();
+        const currency = to.toUpperCase();
+        if (currency === 'RUB' && fromCurrency === 'RUB') {
+            const value = round ? Math.round(this) : ceiled ? Math.ceil(this) : this;
+            //@ts-ignore
+            return new ConvertedNumber(value, `${value.toLocaleString('ru', { maximumFractionDigits: 2 })} RUB`);
+        }
+        else if (currency === 'RUB') {
+            const rates = yield CoinBase_service_1.CoinBaseService.getInstance().getRates('RUB');
+            const targetRate = 1 / Number(rates[fromCurrency]);
+            let convertedAmount = this * Number(targetRate);
+            if (!convertedAmount)
+                convertedAmount = this;
+            if (round) {
+                convertedAmount = Math.round(convertedAmount);
+            }
+            else if (ceiled) {
+                convertedAmount = Math.ceil(convertedAmount);
+            }
+            //@ts-ignore
+            return new ConvertedNumber(convertedAmount, `${convertedAmount.toLocaleString('ru', { maximumFractionDigits: 2 })} ${currency}`);
+        }
+        const rates = yield CoinBase_service_1.CoinBaseService.getInstance().getRates(fromCurrency);
+        const targetRate = rates[currency];
+        let convertedAmount = this * Number(targetRate);
+        if (!convertedAmount)
+            convertedAmount = this;
+        if (round) {
+            convertedAmount = Math.round(convertedAmount);
+        }
+        else if (ceiled) {
+            convertedAmount = Math.ceil(convertedAmount);
+        }
+        //@ts-ignore
+        return new ConvertedNumber(convertedAmount, `${convertedAmount.toLocaleString('ru', { maximumFractionDigits: 2 })} ${targetRate ? currency : 'RUB'}`);
+    });
+};
+String.prototype.convert = function (params) {
+    return Number(this).convert(params);
+};

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './Client';

package/lib/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./Client"), exports);

package/lib/utils/CoinBase.service.d.ts

@@ -0,0 +1,33 @@
+export declare class CoinBaseService {
+    private readonly UPDATE_INTERVAL_MS;
+    private readonly CACHE_LIFETIME_MS;
+    private ratesCache;
+    static instance: CoinBaseService;
+    static getInstance(): CoinBaseService;
+    /**
+     * Проверяет актуальность кэша
+     */
+    private isCacheValid;
+    /**
+     * Получает курсы из кэша
+     */
+    getRates(currency?: string): Promise<{
+        [key: string]: string;
+    }>;
+    /**
+     * Запускает автоматическое обновление курсов для конкретной валюты
+     */
+    private startUpdates;
+    /**
+     * Останавливает обновление для указанной валюты или всех валют
+     */
+    stopUpdates(currency?: string): void;
+    /**
+     * Обновляет курсы криптовалют в кэше
+     */
+    private updateRates;
+    /**
+     * Очищает кэш для указанной валюты или весь кэш
+     */
+    clearCache(currency?: string): void;
+}

package/lib/utils/CoinBase.service.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoinBaseService = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+class CoinBaseService {
+    constructor() {
+        this.UPDATE_INTERVAL_MS = 300000; // 5 минут
+        this.CACHE_LIFETIME_MS = 300000; // Время жизни кэша - 5 минут
+        this.ratesCache = new Map();
+    }
+    static getInstance() {
+        if (!CoinBaseService.instance)
+            CoinBaseService.instance = new CoinBaseService();
+        return CoinBaseService.instance;
+    }
+    /**
+     * Проверяет актуальность кэша
+     */
+    isCacheValid(currency) {
+        const cachedData = this.ratesCache.get(currency);
+        if (!cachedData)
+            return false;
+        const now = Date.now();
+        return now - cachedData.timestamp < this.CACHE_LIFETIME_MS;
+    }
+    /**
+     * Получает курсы из кэша
+     */
+    getRates() {
+        return tslib_1.__awaiter(this, arguments, void 0, function* (currency = 'USD') {
+            // Если валюта не кэширована или кэш устарел, начинаем обновление
+            if (!this.isCacheValid(currency))
+                yield this.startUpdates(currency);
+            const cachedData = this.ratesCache.get(currency);
+            return cachedData.rates;
+        });
+    }
+    /**
+     * Запускает автоматическое обновление курсов для конкретной валюты
+     */
+    startUpdates(currency) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Проверяем, не запущено ли уже обновление для этой валюты
+            const existingCache = this.ratesCache.get(currency);
+            if (existingCache === null || existingCache === void 0 ? void 0 : existingCache.updateInterval)
+                return;
+            // Первое обновление сразу
+            yield this.updateRates(currency);
+            // Создаем новый интервал обновления
+            const updateInterval = setInterval(() => {
+                this.updateRates(currency);
+            }, this.UPDATE_INTERVAL_MS);
+            // Сохраняем или обновляем информацию в кэше
+            this.ratesCache.set(currency, Object.assign(Object.assign({}, this.ratesCache.get(currency)), { updateInterval, timestamp: Date.now(), rates: ((_a = this.ratesCache.get(currency)) === null || _a === void 0 ? void 0 : _a.rates) || {} }));
+        });
+    }
+    /**
+     * Останавливает обновление для указанной валюты или всех валют
+     */
+    stopUpdates(currency) {
+        if (currency) {
+            const cachedData = this.ratesCache.get(currency);
+            if (cachedData === null || cachedData === void 0 ? void 0 : cachedData.updateInterval) {
+                clearInterval(cachedData.updateInterval);
+                cachedData.updateInterval = null;
+            }
+        }
+        else {
+            // Останавливаем все обновления
+            for (const [, data] of this.ratesCache) {
+                if (data.updateInterval) {
+                    clearInterval(data.updateInterval);
+                    data.updateInterval = null;
+                }
+            }
+        }
+    }
+    /**
+     * Обновляет курсы криптовалют в кэше
+     */
+    updateRates(currency) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield axios_1.default.get(`https://api.coinbase.com/v2/exchange-rates?currency=${currency}`);
+                const rates = response.data.data.rates;
+                // Обновляем кэш
+                const existingCache = this.ratesCache.get(currency);
+                this.ratesCache.set(currency, Object.assign(Object.assign({}, existingCache), { rates, timestamp: Date.now() }));
+            }
+            catch (error) {
+                console.error('Ошибка при обновлении курсов криптовалют:', error);
+            }
+        });
+    }
+    /**
+     * Очищает кэш для указанной валюты или весь кэш
+     */
+    clearCache(currency) {
+        if (currency) {
+            // Останавливаем обновления перед удалением
+            this.stopUpdates(currency);
+            this.ratesCache.delete(currency);
+        }
+        else {
+            // Останавливаем все обновления перед очисткой
+            this.stopUpdates();
+            this.ratesCache.clear();
+        }
+    }
+}
+exports.CoinBaseService = CoinBaseService;