smartxtrader 3.8.1-xm.0

package/src/javascript/app/common/telegram_auth.js

@@ -0,0 +1,682 @@
+const ClientBase = require('../../_common/base/client_base');
+const { LocalStore } = require('../../_common/storage');
+const { getTelegramBridgeUrl, getTelegramBotUsername } = require('../../config');
+
+const openWindowSafely = (url, target = '_blank') => {
+    if (!url) return;
+
+    try {
+        const win = window.open(url, target, 'noopener');
+        if (!win) {
+            window.location.href = url;
+        }
+    } catch (error) {
+        window.location.href = url;
+    }
+};
+
+const openTelegramLink = (url) => {
+    if (!url) return;
+
+    const telegram_webapp = window.Telegram && window.Telegram.WebApp;
+
+    if (telegram_webapp?.openTelegramLink) {
+        telegram_webapp.openTelegramLink(url);
+        return;
+    }
+
+    if (telegram_webapp?.openLink) {
+        telegram_webapp.openLink(url);
+        return;
+    }
+
+    openWindowSafely(url);
+};
+
+const openTelegramMiniApp = (url) => {
+    if (!url) return;
+
+    const telegram_webapp = window.Telegram && window.Telegram.WebApp;
+
+    if (telegram_webapp?.openApp) {
+        telegram_webapp.openApp(url);
+        return;
+    }
+
+    openTelegramLink(url);
+};
+
+const TELEGRAM_METADATA_PREFIX = 'tg_';
+const TELEGRAM_KNOWN_PARAMS = ['intent', 'intent_id', 'telegram_intent', 'start', 'startapp', 'chat_id'];
+const TELEGRAM_BRIDGE_TIMEOUT_MS = 5000;
+
+const isTelegramWebApp = () => {
+    try {
+        return !!(window.Telegram && window.Telegram.WebApp);
+    } catch (error) {
+        return false;
+    }
+};
+
+const getTelegramInitDataUnsafe = () => {
+    if (!isTelegramWebApp()) return null;
+
+    try {
+        return window.Telegram.WebApp.initDataUnsafe || null;
+    } catch (error) {
+        return null;
+    }
+};
+
+const getTelegramStartParam = () => {
+    const unsafe = getTelegramInitDataUnsafe();
+    if (!unsafe) return null;
+
+    return typeof unsafe.start_param === 'undefined' ? null : unsafe.start_param;
+};
+
+const normalizeBase64 = (value) => {
+    if (!value || typeof value !== 'string') return null;
+
+    const sanitized = value.replace(/-/g, '+').replace(/_/g, '/');
+    const padding = sanitized.length % 4 ? 4 - (sanitized.length % 4) : 0;
+
+    return sanitized + '='.repeat(padding);
+};
+
+const decodeBase64Json = (value) => {
+    try {
+        const normalized = normalizeBase64(value);
+        if (!normalized) return null;
+        const decoded = atob(normalized);
+        return JSON.parse(decoded);
+    } catch (error) {
+        return null;
+    }
+};
+
+const collectTelegramMetadataFromUrl = () => {
+    if (typeof window === 'undefined' || !window.location) return null;
+
+    const metadata = {};
+    const appendParams = (search_string) => {
+        if (!search_string) return;
+
+        let query = search_string;
+        if (query.startsWith('?') || query.startsWith('#')) {
+            query = query.slice(1);
+        }
+
+        if (!query) return;
+
+        query.split('&').forEach((pair) => {
+            if (!pair) return;
+            const [raw_key, raw_value = ''] = pair.split('=');
+            if (!raw_key) return;
+
+            const key = decodeURIComponent(raw_key);
+            const value = decodeURIComponent(raw_value);
+
+            if (!key) return;
+
+            if (key.startsWith(TELEGRAM_METADATA_PREFIX)) {
+                const normalized_key = key.slice(TELEGRAM_METADATA_PREFIX.length);
+                if (normalized_key && typeof metadata[normalized_key] === 'undefined') {
+                    metadata[normalized_key] = value;
+                }
+                return;
+            }
+
+            if (TELEGRAM_KNOWN_PARAMS.includes(key) && typeof metadata[key] === 'undefined') {
+                metadata[key] = value;
+            }
+        });
+    };
+
+    appendParams(window.location.search || '');
+    const hash = window.location.hash || '';
+    if (hash.includes('?')) {
+        appendParams(hash.substring(hash.indexOf('?')));
+    } else {
+        appendParams(hash);
+    }
+
+    return Object.keys(metadata).length ? metadata : null;
+};
+
+const mergeMetadata = (base, addition, { override = false } = {}) => {
+    const result = { ...(base || {}) };
+
+    if (addition && typeof addition === 'object') {
+        Object.keys(addition).forEach((key) => {
+            if (!key) return;
+            if (!override && typeof result[key] !== 'undefined') return;
+
+            result[key] = addition[key];
+        });
+    }
+
+    return result;
+};
+
+const collectTelegramInitMetadata = () => {
+    const init_data = getTelegramInitDataUnsafe();
+    if (!init_data || typeof init_data !== 'object') return null;
+
+    const metadata = {};
+
+    if (init_data.query_id && typeof metadata.query_id === 'undefined') {
+        metadata.query_id = init_data.query_id;
+    }
+
+    if (init_data.user && typeof init_data.user === 'object') {
+        if (init_data.user.id && typeof metadata.user_id === 'undefined') {
+            metadata.user_id = init_data.user.id;
+        }
+        if (init_data.user.username && typeof metadata.username === 'undefined') {
+            metadata.username = init_data.user.username;
+        }
+    }
+
+    if (init_data.chat && typeof init_data.chat === 'object') {
+        if (init_data.chat.id && typeof metadata.chat_id === 'undefined') {
+            metadata.chat_id = init_data.chat.id;
+        }
+    }
+
+    return Object.keys(metadata).length ? metadata : null;
+};
+
+const collectTelegramMetadata = () => {
+    let metadata = collectTelegramMetadataFromUrl() || {};
+    const start_param = getTelegramStartParam();
+
+    if (start_param && typeof metadata.start_param === 'undefined') {
+        metadata.start_param = start_param;
+        const decoded_start = decodeBase64Json(start_param);
+        if (decoded_start && typeof decoded_start === 'object') {
+            metadata = mergeMetadata(metadata, decoded_start);
+        }
+    }
+
+    metadata = mergeMetadata(metadata, collectTelegramInitMetadata());
+
+    const bot_username = getTelegramBotUsername();
+    if (bot_username && typeof metadata.bot_username === 'undefined') {
+        metadata.bot_username = bot_username;
+    }
+
+    return Object.keys(metadata).length ? metadata : null;
+};
+
+const gatherTelegramMetadata = (intent) => {
+    let metadata = {};
+
+    if (intent && intent.telegram_metadata) {
+        metadata = mergeMetadata(metadata, intent.telegram_metadata, { override: true });
+    }
+
+    metadata = mergeMetadata(metadata, collectTelegramMetadata());
+
+    if (intent && intent.id && typeof metadata.intent_id === 'undefined') {
+        metadata.intent_id = intent.id;
+    }
+
+    return Object.keys(metadata).length ? metadata : null;
+};
+
+const openTelegramAuthBot = (intent, options = {}) => {
+    const bot_username = options.bot_username || getTelegramBotUsername();
+    const payload = options.payload || (intent && intent.id);
+
+    if (!bot_username || !payload) return false;
+
+    const encoded_payload = encodeURIComponent(String(payload));
+    const base_url = `https://t.me/${bot_username}`;
+    const mode = (options.mode || window.TELEGRAM_BOT_START_MODE || '').toLowerCase();
+    const should_open_mini_app = ['startapp', 'miniapp', 'app'].includes(mode);
+
+    if (should_open_mini_app) {
+        openTelegramMiniApp(`${base_url}?startapp=${encoded_payload}`);
+        if (options.fallbackToStart === true) {
+            openTelegramLink(`${base_url}?start=${encoded_payload}`);
+        }
+        return true;
+    }
+
+    openTelegramLink(`${base_url}?start=${encoded_payload}`);
+    return true;
+};
+
+const TelegramAuth = (() => {
+    const STORAGE_KEY = 'telegram.auth.intent';
+    const STORAGE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+    const storage = (() => {
+        try {
+            return window.sessionStorage;
+        } catch (error) {
+            return null;
+        }
+    })();
+
+    const persistIntent = (intent) => {
+        if (!storage) return;
+        try {
+            storage.setItem(STORAGE_KEY, JSON.stringify(intent));
+        } catch (error) {
+            // ignore storage errors (e.g. private mode)
+        }
+    };
+
+    const clearIntent = () => {
+        if (!storage) return;
+        storage.removeItem(STORAGE_KEY);
+    };
+
+    const readIntentFromStorage = () => {
+        if (!storage) return null;
+        try {
+            const raw = storage.getItem(STORAGE_KEY);
+            if (!raw) return null;
+            const parsed = JSON.parse(raw);
+            if (!parsed || typeof parsed !== 'object') {
+                clearIntent();
+                return null;
+            }
+            return parsed;
+        } catch (error) {
+            clearIntent();
+            return null;
+        }
+    };
+
+    const cleanupIntent = () => {
+        if (!storage) return;
+        const intent = readIntentFromStorage();
+        if (!intent) return;
+
+        const timestamp = Number(intent.timestamp);
+        if (!timestamp || Date.now() - timestamp > STORAGE_TTL_MS) {
+            clearIntent();
+        }
+    };
+
+    const generateIntentId = () => {
+        if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+            return crypto.randomUUID();
+        }
+        return `tg_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+    };
+
+    const createIntent = (id, metadata, options = {}) => {
+        if (!id) return null;
+
+        const intent = {
+            id       : String(id),
+            timestamp: Date.now(),
+        };
+
+        if (metadata && typeof metadata === 'object' && Object.keys(metadata).length) {
+            intent.telegram_metadata = metadata;
+        }
+
+        if (options && options.source) {
+            intent.source = options.source;
+        }
+
+        return intent;
+    };
+
+    const captureIntentFromUrl = (options = {}) => {
+        if (!storage) return null;
+
+        const collected_metadata = collectTelegramMetadata();
+        let metadata = mergeMetadata(collected_metadata || {}, options.metadata, { override: true });
+
+        if (!metadata || !Object.keys(metadata).length) {
+            return null;
+        }
+
+        let intent_id = options.intent_id
+            || metadata.intent_id
+            || metadata.intent
+            || metadata.telegram_intent
+            || metadata.start
+            || metadata.startapp
+            || metadata.start_param
+            || metadata.query_id
+            || metadata.chat_id
+            || metadata.user_id;
+
+        if (!intent_id) {
+            const unsafe = getTelegramInitDataUnsafe();
+            if (unsafe?.query_id) {
+                intent_id = unsafe.query_id;
+                metadata = mergeMetadata(metadata, { query_id: unsafe.query_id });
+            } else if (unsafe?.user?.id) {
+                intent_id = unsafe.user.id;
+                metadata = mergeMetadata(metadata, { user_id: unsafe.user.id });
+            }
+        }
+
+        if (!intent_id) {
+            return null;
+        }
+
+        const intent = createIntent(intent_id, metadata, options);
+        persistIntent(intent);
+        return intent;
+    };
+
+    const getIntent = () => {
+        if (!storage) return null;
+
+        cleanupIntent();
+
+        const intent = readIntentFromStorage();
+        if (intent) return intent;
+
+        return captureIntentFromUrl();
+    };
+
+    const safeClone = (value) => {
+        if (!value) return undefined;
+        try {
+            return JSON.parse(JSON.stringify(value));
+        } catch (error) {
+            return undefined;
+        }
+    };
+
+    const safeJsonParse = (value) => {
+        if (!value || typeof value !== 'string') return null;
+        try {
+            return JSON.parse(value);
+        } catch (error) {
+            return null;
+        }
+    };
+
+    const safeLocalStorageGet = (key) => {
+        if (!key) return null;
+        try {
+            const storage = window.localStorage;
+            if (!storage) return null;
+            return storage.getItem(key);
+        } catch (error) {
+            return null;
+        }
+    };
+
+    const getUiTheme = () => {
+        try {
+            const html = document.documentElement;
+            if (html) {
+                const datasetTheme = html.dataset && (html.dataset.uiTheme || html.dataset.theme);
+                if (datasetTheme) return datasetTheme;
+                const attrTheme = html.getAttribute('data-theme');
+                if (attrTheme) return attrTheme;
+            }
+
+            const storedTheme = LocalStore.get('ui.theme')
+                || LocalStore.get('trading_ui_theme')
+                || LocalStore.get('theme');
+            if (storedTheme) return storedTheme;
+
+            const prefersDark = window.matchMedia
+                && window.matchMedia('(prefers-color-scheme: dark)').matches;
+            return prefersDark ? 'dark' : 'light';
+        } catch (error) {
+            return null;
+        }
+    };
+
+    const getChartPreferences = () => {
+        const preferences = {};
+
+        const theme = safeLocalStorageGet('smartcharts.theme');
+        if (theme) {
+            preferences.theme = theme;
+        }
+
+        const chartType = safeLocalStorageGet('smartcharts.chartType');
+        if (chartType) {
+            preferences.chart_type = chartType;
+        }
+
+        const layout = safeJsonParse(safeLocalStorageGet('smartcharts.chartLayout'));
+        if (layout) {
+            preferences.layout = layout;
+        }
+
+        const style = safeJsonParse(safeLocalStorageGet('smartcharts.chartStyle'));
+        if (style) {
+            preferences.style = style;
+        }
+
+        return Object.keys(preferences).length ? preferences : null;
+    };
+
+    const getTelegramInitPayload = () => {
+        const telegram_webapp = window.Telegram && window.Telegram.WebApp;
+        if (!telegram_webapp) return null;
+
+        const init_data = telegram_webapp.initData || '';
+        if (!init_data) return null;
+
+        const unsafe = telegram_webapp.initDataUnsafe;
+        const payload = { init_data };
+
+        const user = safeClone(unsafe && unsafe.user);
+        const chat = safeClone(unsafe && unsafe.chat);
+
+        if (user) {
+            payload.user = user;
+        }
+
+        if (chat) {
+            payload.chat = chat;
+        }
+
+        return payload;
+    };
+
+    const start = (options = {}) => {
+        if (!storage) return null;
+
+        const metadata = mergeMetadata(collectTelegramMetadata() || {}, options.metadata, { override: true });
+        const intent_id = options.intent_id || generateIntentId();
+        const intent = createIntent(intent_id, metadata, options);
+
+        persistIntent(intent);
+        return intent;
+    };
+
+    const isPending = () => !!getIntent();
+
+    const getActiveAccounts = () => {
+        const loginids = ClientBase.getAllLoginids();
+        return loginids.map((loginid) => ({
+            loginid,
+            token         : ClientBase.get('token', loginid),
+            currency      : ClientBase.get('currency', loginid),
+            is_virtual    : ClientBase.get('is_virtual', loginid),
+            account_type  : ClientBase.getAccountType(loginid),
+            landing_company: ClientBase.get('landing_company_shortcode', loginid),
+        })).filter(account => account.token);
+    };
+
+    const buildPayload = (intent) => {
+        const active_loginid = ClientBase.get('loginid');
+        const payload = {
+            intent_id      : intent.id,
+            active_loginid,
+            email          : ClientBase.get('email'),
+            residence      : ClientBase.get('residence'),
+            session_start  : ClientBase.get('session_start'),
+            accounts       : getActiveAccounts(),
+            locale         : LocalStore.get('preferred_language') || document.documentElement.lang || 'en',
+            timestamp      : intent.timestamp,
+            redirect_url   : (storage && storage.getItem('redirect_url')) || window.location.href,
+        };
+
+        const ui_theme = getUiTheme();
+        if (ui_theme) {
+            payload.ui_theme = ui_theme;
+        }
+
+        const chart_preferences = getChartPreferences();
+        if (chart_preferences) {
+            payload.chart = chart_preferences;
+        }
+
+        const telegram_init_payload = getTelegramInitPayload();
+        const telegram_metadata = gatherTelegramMetadata(intent);
+
+        if (telegram_init_payload || telegram_metadata) {
+            const telegram_payload = telegram_init_payload ? { ...telegram_init_payload } : {};
+            if (telegram_metadata) {
+                telegram_payload.metadata = mergeMetadata(telegram_payload.metadata, telegram_metadata, { override: true });
+                payload.telegram_metadata = telegram_metadata;
+            }
+            payload.telegram = telegram_payload;
+        }
+
+        return payload;
+    };
+
+    const parseResponse = async (response) => {
+        const content_type = response.headers.get('content-type') || '';
+        if (content_type.includes('application/json')) {
+            return response.json();
+        }
+        return response.text();
+    };
+
+    const handleBridgeResponse = (bridge_response) => {
+        if (!bridge_response) return;
+
+        if (typeof bridge_response === 'object') {
+            if (bridge_response.telegram_mini_app_url) {
+                openTelegramMiniApp(bridge_response.telegram_mini_app_url);
+            } else if (bridge_response.telegram_web_app_url) {
+                openTelegramMiniApp(bridge_response.telegram_web_app_url);
+            } else if (bridge_response.telegram_deep_link) {
+                openTelegramLink(bridge_response.telegram_deep_link);
+            }
+            if (bridge_response.message) {
+                console.info('[TelegramAuth]', bridge_response.message);
+            }
+            if (bridge_response.redirect_url) {
+                window.location.href = bridge_response.redirect_url;
+            }
+        }
+    };
+
+    const createTimeoutError = () => {
+        const error = new Error('Telegram bridge request timed out.');
+        error.code = 'TELEGRAM_AUTH_TIMEOUT';
+        return error;
+    };
+
+    const fetchWithTimeout = (url, options = {}, timeout_ms = TELEGRAM_BRIDGE_TIMEOUT_MS) => {
+        if (!timeout_ms) {
+            return fetch(url, options);
+        }
+
+        const supports_abort = typeof AbortController === 'function';
+
+        if (supports_abort) {
+            const controller = new AbortController();
+            const timeout_id = setTimeout(() => controller.abort(), timeout_ms);
+
+            return fetch(url, { ...options, signal: controller.signal })
+                .catch((error) => {
+                    if (error.name === 'AbortError') {
+                        throw createTimeoutError();
+                    }
+                    throw error;
+                })
+                .finally(() => {
+                    clearTimeout(timeout_id);
+                });
+        }
+
+        let timeout_id;
+        const timeout_promise = new Promise((_, reject) => {
+            timeout_id = setTimeout(() => {
+                reject(createTimeoutError());
+            }, timeout_ms);
+        });
+
+        return Promise.race([
+            fetch(url, options),
+            timeout_promise,
+        ]).finally(() => {
+            if (timeout_id) {
+                clearTimeout(timeout_id);
+            }
+        });
+    };
+
+    const complete = async () => {
+        let intent = getIntent();
+        if (!intent) {
+            intent = captureIntentFromUrl();
+        }
+        if (!intent) return null;
+
+        const telegram_url = getTelegramBridgeUrl();
+        if (!telegram_url) {
+            clearIntent();
+            return null;
+        }
+
+        const payload = buildPayload(intent);
+
+        try {
+            const response = await fetchWithTimeout(telegram_url, {
+                method : 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body        : JSON.stringify(payload),
+                credentials : 'include',
+            });
+
+            const bridge_response = await parseResponse(response);
+
+            handleBridgeResponse(bridge_response);
+
+            if (!response.ok) {
+                const error = new Error('Telegram bridge rejected the XYZSTRATEGY authorization payload.');
+                error.bridge_response = bridge_response;
+                throw error;
+            }
+
+            return bridge_response;
+        } catch (error) {
+            console.error('[TelegramAuth] Failed to notify Telegram bridge.', error);
+            throw error;
+        } finally {
+            clearIntent();
+        }
+    };
+
+    cleanupIntent();
+
+    return {
+        start,
+        isPending,
+        complete,
+        clear     : clearIntent,
+        openBot   : openTelegramAuthBot,
+        isWebApp  : isTelegramWebApp,
+        getIntentId: () => {
+            const intent = getIntent();
+            return intent && intent.id;
+        },
+    };
+})();
+
+module.exports = TelegramAuth;