From 365f3113e53261a120508e3e200ce3bd1eb6a0da Mon Sep 17 00:00:00 2001
From: Rupato Braganza <rupato@deriv.com>
Date: Thu, 16 Oct 2025 13:35:28 +0800
Subject: [PATCH 1/9] fix: enabled language switcher dbot

---
 src/components/layout/footer/index.tsx        | 28 +++++++++----------
 .../layout/header/mobile-menu/mobile-menu.tsx | 26 +++++++++++++++--
 src/utils/languages.tsx                       |  5 ++++
 3 files changed, 42 insertions(+), 17 deletions(-)

diff --git a/src/components/layout/footer/index.tsx b/src/components/layout/footer/index.tsx
index 75483c8f..59e8989c 100644
--- a/src/components/layout/footer/index.tsx
+++ b/src/components/layout/footer/index.tsx
@@ -1,26 +1,26 @@
-// import useModalManager from '@/hooks/useModalManager';
-// import { getActiveTabUrl } from '@/utils/getActiveTabUrl';
-// import { LANGUAGES } from '@/utils/languages';
-// import { useTranslations } from '@deriv-com/translations';
-// import { DesktopLanguagesModal } from '@deriv-com/ui';
+import useModalManager from '@/hooks/useModalManager';
+import { getActiveTabUrl } from '@/utils/getActiveTabUrl';
+import { FILTERED_LANGUAGES } from '@/utils/languages';
+import { useTranslations } from '@deriv-com/translations';
+import { DesktopLanguagesModal } from '@deriv-com/ui';
 import ChangeTheme from './ChangeTheme';
 import Endpoint from './Endpoint';
 import FullScreen from './FullScreen';
-// import LanguageSettings from './LanguageSettings';
+import LanguageSettings from './LanguageSettings';
 import NetworkStatus from './NetworkStatus';
 import ServerTime from './ServerTime';
 import './footer.scss';
 
 const Footer = () => {
-    // const { currentLang = 'EN', localize, switchLanguage } = useTranslations();
-    // const { hideModal, isModalOpenFor, showModal } = useModalManager();
+    const { currentLang = 'EN', localize, switchLanguage } = useTranslations();
+    const { hideModal, isModalOpenFor, showModal } = useModalManager();
 
-    // const openLanguageSettingModal = () => showModal('DesktopLanguagesModal');
+    const openLanguageSettingModal = () => showModal('DesktopLanguagesModal');
     return (
         <footer className='app-footer'>
             <FullScreen />
-            {/* <LanguageSettings openLanguageSettingModal={openLanguageSettingModal} />
-            <div className='app-footer__vertical-line' /> */}
+            <LanguageSettings openLanguageSettingModal={openLanguageSettingModal} />
+            <div className='app-footer__vertical-line' />
             <ChangeTheme />
             <div className='app-footer__vertical-line' />
             <ServerTime />
@@ -28,11 +28,11 @@ const Footer = () => {
             <NetworkStatus />
             <Endpoint />
 
-            {/* {isModalOpenFor('DesktopLanguagesModal') && (
+            {isModalOpenFor('DesktopLanguagesModal') && (
                 <DesktopLanguagesModal
                     headerTitle={localize('Select Language')}
                     isModalOpen
-                    languages={LANGUAGES}
+                    languages={FILTERED_LANGUAGES}
                     onClose={hideModal}
                     onLanguageSwitch={code => {
                         switchLanguage(code);
@@ -42,7 +42,7 @@ const Footer = () => {
                     }}
                     selectedLanguage={currentLang}
                 />
-            )} */}
+            )}
         </footer>
     );
 };
diff --git a/src/components/layout/header/mobile-menu/mobile-menu.tsx b/src/components/layout/header/mobile-menu/mobile-menu.tsx
index 9717fcbc..df58abc5 100644
--- a/src/components/layout/header/mobile-menu/mobile-menu.tsx
+++ b/src/components/layout/header/mobile-menu/mobile-menu.tsx
@@ -1,6 +1,9 @@
 import { useState } from 'react';
+import useModalManager from '@/hooks/useModalManager';
+import { getActiveTabUrl } from '@/utils/getActiveTabUrl';
+import { FILTERED_LANGUAGES } from '@/utils/languages';
 import { useTranslations } from '@deriv-com/translations';
-import { Drawer, useDevice } from '@deriv-com/ui';
+import { Drawer, MobileLanguagesDrawer,useDevice } from '@deriv-com/ui';
 import NetworkStatus from './../../footer/NetworkStatus';
 import ServerTime from './../../footer/ServerTime';
 import BackButton from './back-button';
@@ -17,7 +20,8 @@ type TMobileMenuProps = {
 const MobileMenu = ({ onLogout }: TMobileMenuProps) => {
     const [isDrawerOpen, setIsDrawerOpen] = useState(false);
     const [activeSubmenu, setActiveSubmenu] = useState<string | null>(null);
-    const { localize } = useTranslations();
+    const { currentLang = 'EN', localize, switchLanguage } = useTranslations();
+    const { hideModal, isModalOpenFor, showModal } = useModalManager();
     const { isDesktop } = useDevice();
 
     const openDrawer = () => setIsDrawerOpen(true);
@@ -28,6 +32,7 @@ const MobileMenu = ({ onLogout }: TMobileMenuProps) => {
 
     const openSubmenu = (submenu: string) => setActiveSubmenu(submenu);
     const closeSubmenu = () => setActiveSubmenu(null);
+    const openLanguageSetting = () => showModal('MobileLanguagesDrawer');
 
     if (isDesktop) return null;
     return (
@@ -38,7 +43,7 @@ const MobileMenu = ({ onLogout }: TMobileMenuProps) => {
 
             <Drawer isOpen={isDrawerOpen} onCloseDrawer={closeDrawer} width='29.5rem'>
                 <Drawer.Header onCloseDrawer={closeDrawer}>
-                    <MenuHeader hideLanguageSetting={true} openLanguageSetting={() => {}} />
+                    <MenuHeader hideLanguageSetting={false} openLanguageSetting={openLanguageSetting} />
                 </Drawer.Header>
 
                 <Drawer.Content>
@@ -65,6 +70,21 @@ const MobileMenu = ({ onLogout }: TMobileMenuProps) => {
                     <NetworkStatus />
                 </Drawer.Footer>
             </Drawer>
+
+            {isModalOpenFor('MobileLanguagesDrawer') && (
+                <MobileLanguagesDrawer
+                    isOpen
+                    languages={FILTERED_LANGUAGES}
+                    onClose={hideModal}
+                    onLanguageSwitch={(code: string) => {
+                        switchLanguage(code);
+                        hideModal();
+                        window.location.replace(getActiveTabUrl());
+                        window.location.reload();
+                    }}
+                    selectedLanguage={currentLang}
+                />
+            )}
         </div>
     );
 };
diff --git a/src/utils/languages.tsx b/src/utils/languages.tsx
index 9a77ac8a..d808eae6 100644
--- a/src/utils/languages.tsx
+++ b/src/utils/languages.tsx
@@ -165,3 +165,8 @@ export const LANGUAGES = [
         placeholderIconInMobile: <FlagChinaTraditionalIcon height={14.67} width={22} />,
     },
 ];
+
+// Filtered languages for the language switcher (only show specific languages)
+export const FILTERED_LANGUAGES = LANGUAGES.filter(lang =>
+    ['EN', 'ES', 'FR', 'PT', 'AR', 'IT', 'RU'].includes(lang.code)
+);

From 7d2aaf15d11c4423e388b10f7a3f5d2739c04403 Mon Sep 17 00:00:00 2001
From: Rupato Braganza <rupato@deriv.com>
Date: Thu, 16 Oct 2025 13:39:37 +0800
Subject: [PATCH 2/9] fix: param based language switching

---
 src/app/App.tsx | 42 +++++++++++++++++++++++++++++++++---------
 1 file changed, 33 insertions(+), 9 deletions(-)

diff --git a/src/app/App.tsx b/src/app/App.tsx
index 039e85fb..478da502 100644
--- a/src/app/App.tsx
+++ b/src/app/App.tsx
@@ -10,7 +10,7 @@ import { StoreProvider } from '@/hooks/useStore';
 import CallbackPage from '@/pages/callback';
 import Endpoint from '@/pages/endpoint';
 import { TAuthData } from '@/types/api-types';
-import { initializeI18n, localize, TranslationProvider } from '@deriv-com/translations';
+import { initializeI18n, localize, TranslationProvider, useTranslations } from '@deriv-com/translations';
 import CoreStoreProvider from './CoreStoreProvider';
 import './app-root.scss';
 
@@ -22,6 +22,28 @@ const i18nInstance = initializeI18n({
     cdnUrl: `${TRANSLATIONS_CDN_URL || 'https://translations.deriv.com'}/${R2_PROJECT_NAME}/${CROWDIN_BRANCH_NAME}`,
 });
 
+// Component to handle language URL parameter
+const LanguageHandler = ({ children }: { children: React.ReactNode }) => {
+    const { switchLanguage } = useTranslations();
+
+    React.useEffect(() => {
+        const urlParams = new URLSearchParams(window.location.search);
+        const langParam = urlParams.get('lang');
+
+        if (langParam) {
+            // Convert to uppercase to match our language codes
+            const langCode = langParam.toUpperCase();
+            // Only switch if it's one of our supported filtered languages
+            const supportedLangs = ['EN', 'ES', 'FR', 'PT', 'AR', 'IT', 'RU'];
+            if (supportedLangs.includes(langCode)) {
+                switchLanguage(langCode);
+            }
+        }
+    }, [switchLanguage]);
+
+    return <>{children}</>;
+};
+
 const router = createBrowserRouter(
     createRoutesFromElements(
         <Route
@@ -31,14 +53,16 @@ const router = createBrowserRouter(
                     fallback={<ChunkLoader message={localize('Please wait while we connect to the server...')} />}
                 >
                     <TranslationProvider defaultLang='EN' i18nInstance={i18nInstance}>
-                        <StoreProvider>
-                            <LocalStorageSyncWrapper>
-                                <RoutePromptDialog />
-                                <CoreStoreProvider>
-                                    <Layout />
-                                </CoreStoreProvider>
-                            </LocalStorageSyncWrapper>
-                        </StoreProvider>
+                        <LanguageHandler>
+                            <StoreProvider>
+                                <LocalStorageSyncWrapper>
+                                    <RoutePromptDialog />
+                                    <CoreStoreProvider>
+                                        <Layout />
+                                    </CoreStoreProvider>
+                                </LocalStorageSyncWrapper>
+                            </StoreProvider>
+                        </LanguageHandler>
                     </TranslationProvider>
                 </Suspense>
             }

From 63bfc9555fb5099369a7a644971674351e9f50ae Mon Sep 17 00:00:00 2001
From: Rupato Braganza <rupato@deriv.com>
Date: Thu, 16 Oct 2025 14:14:52 +0800
Subject: [PATCH 3/9] fix: Rupato/Enable--language-switcher-on-dbot

---
 .../layout/header/mobile-menu/menu-header.tsx |  4 +-
 .../layout/header/mobile-menu/mobile-menu.tsx | 45 +++++++++++--------
 2 files changed, 29 insertions(+), 20 deletions(-)

diff --git a/src/components/layout/header/mobile-menu/menu-header.tsx b/src/components/layout/header/mobile-menu/menu-header.tsx
index 98e509ea..50aa16cf 100644
--- a/src/components/layout/header/mobile-menu/menu-header.tsx
+++ b/src/components/layout/header/mobile-menu/menu-header.tsx
@@ -1,5 +1,5 @@
 import { ComponentProps, useMemo } from 'react';
-import { LANGUAGES } from '@/utils/languages';
+import { FILTERED_LANGUAGES } from '@/utils/languages';
 import { useTranslations } from '@deriv-com/translations';
 import { Text, useDevice } from '@deriv-com/ui';
 
@@ -13,7 +13,7 @@ const MenuHeader = ({ hideLanguageSetting, openLanguageSetting }: TMenuHeader) =
     const { isDesktop } = useDevice();
 
     const countryIcon = useMemo(
-        () => LANGUAGES.find(({ code }) => code === currentLang)?.placeholderIconInMobile,
+        () => FILTERED_LANGUAGES.find(({ code }) => code === currentLang)?.placeholderIconInMobile,
         [currentLang]
     );
 
diff --git a/src/components/layout/header/mobile-menu/mobile-menu.tsx b/src/components/layout/header/mobile-menu/mobile-menu.tsx
index df58abc5..e488fb24 100644
--- a/src/components/layout/header/mobile-menu/mobile-menu.tsx
+++ b/src/components/layout/header/mobile-menu/mobile-menu.tsx
@@ -3,7 +3,7 @@ import useModalManager from '@/hooks/useModalManager';
 import { getActiveTabUrl } from '@/utils/getActiveTabUrl';
 import { FILTERED_LANGUAGES } from '@/utils/languages';
 import { useTranslations } from '@deriv-com/translations';
-import { Drawer, MobileLanguagesDrawer,useDevice } from '@deriv-com/ui';
+import { Drawer, MobileLanguagesDrawer, useDevice } from '@deriv-com/ui';
 import NetworkStatus from './../../footer/NetworkStatus';
 import ServerTime from './../../footer/ServerTime';
 import BackButton from './back-button';
@@ -33,6 +33,7 @@ const MobileMenu = ({ onLogout }: TMobileMenuProps) => {
     const openSubmenu = (submenu: string) => setActiveSubmenu(submenu);
     const closeSubmenu = () => setActiveSubmenu(null);
     const openLanguageSetting = () => showModal('MobileLanguagesDrawer');
+    const isLanguageSettingVisible = Boolean(isModalOpenFor('MobileLanguagesDrawer'));
 
     if (isDesktop) return null;
     return (
@@ -43,11 +44,34 @@ const MobileMenu = ({ onLogout }: TMobileMenuProps) => {
 
             <Drawer isOpen={isDrawerOpen} onCloseDrawer={closeDrawer} width='29.5rem'>
                 <Drawer.Header onCloseDrawer={closeDrawer}>
-                    <MenuHeader hideLanguageSetting={false} openLanguageSetting={openLanguageSetting} />
+                    <MenuHeader
+                        hideLanguageSetting={isLanguageSettingVisible}
+                        openLanguageSetting={openLanguageSetting}
+                    />
                 </Drawer.Header>
 
                 <Drawer.Content>
-                    {activeSubmenu === 'reports' ? (
+                    {isLanguageSettingVisible ? (
+                        <>
+                            <div className='mobile-menu__back-btn'>
+                                <BackButton buttonText={localize('Language')} onClick={hideModal} />
+                            </div>
+
+                            <MobileLanguagesDrawer
+                                isOpen
+                                languages={FILTERED_LANGUAGES}
+                                onClose={hideModal}
+                                onLanguageSwitch={code => {
+                                    switchLanguage(code);
+                                    hideModal();
+                                    window.location.replace(getActiveTabUrl());
+                                    window.location.reload();
+                                }}
+                                selectedLanguage={currentLang}
+                                wrapperClassName='mobile-menu__language-drawer'
+                            />
+                        </>
+                    ) : activeSubmenu === 'reports' ? (
                         <>
                             <div className='mobile-menu__back-btn'>
                                 <BackButton buttonText={localize('Reports')} onClick={closeSubmenu} />
@@ -70,21 +94,6 @@ const MobileMenu = ({ onLogout }: TMobileMenuProps) => {
                     <NetworkStatus />
                 </Drawer.Footer>
             </Drawer>
-
-            {isModalOpenFor('MobileLanguagesDrawer') && (
-                <MobileLanguagesDrawer
-                    isOpen
-                    languages={FILTERED_LANGUAGES}
-                    onClose={hideModal}
-                    onLanguageSwitch={(code: string) => {
-                        switchLanguage(code);
-                        hideModal();
-                        window.location.replace(getActiveTabUrl());
-                        window.location.reload();
-                    }}
-                    selectedLanguage={currentLang}
-                />
-            )}
         </div>
     );
 };

From e37e52b3c8815cbe031adb238b1c2640d2be5f20 Mon Sep 17 00:00:00 2001
From: Rupato Braganza <rupato@deriv.com>
Date: Thu, 16 Oct 2025 14:26:28 +0800
Subject: [PATCH 4/9] fix: claude comments

---
 src/app/App.tsx                               | 20 ++++++++++++++-----
 .../layout/footer/LanguageSettings.tsx        |  7 +++++--
 src/components/layout/footer/index.tsx        | 15 ++++++++++----
 .../layout/header/mobile-menu/menu-header.tsx |  8 +++++++-
 .../layout/header/mobile-menu/mobile-menu.tsx | 15 ++++++++++----
 5 files changed, 49 insertions(+), 16 deletions(-)

diff --git a/src/app/App.tsx b/src/app/App.tsx
index 478da502..251aec56 100644
--- a/src/app/App.tsx
+++ b/src/app/App.tsx
@@ -10,6 +10,7 @@ import { StoreProvider } from '@/hooks/useStore';
 import CallbackPage from '@/pages/callback';
 import Endpoint from '@/pages/endpoint';
 import { TAuthData } from '@/types/api-types';
+import { FILTERED_LANGUAGES } from '@/utils/languages';
 import { initializeI18n, localize, TranslationProvider, useTranslations } from '@deriv-com/translations';
 import CoreStoreProvider from './CoreStoreProvider';
 import './app-root.scss';
@@ -32,11 +33,20 @@ const LanguageHandler = ({ children }: { children: React.ReactNode }) => {
 
         if (langParam) {
             // Convert to uppercase to match our language codes
-            const langCode = langParam.toUpperCase();
-            // Only switch if it's one of our supported filtered languages
-            const supportedLangs = ['EN', 'ES', 'FR', 'PT', 'AR', 'IT', 'RU'];
-            if (supportedLangs.includes(langCode)) {
-                switchLanguage(langCode);
+            const langCode = langParam.toUpperCase() as (typeof FILTERED_LANGUAGES)[number]['code'];
+            // Use FILTERED_LANGUAGES instead of hard-coded array
+            const supportedLangCodes = FILTERED_LANGUAGES.map(lang => lang.code);
+
+            if (supportedLangCodes.includes(langCode)) {
+                try {
+                    switchLanguage(langCode);
+                    // Remove lang parameter after processing to avoid URL pollution
+                    const url = new URL(window.location.href);
+                    url.searchParams.delete('lang');
+                    window.history.replaceState({}, '', url.toString());
+                } catch (error) {
+                    console.error('Failed to switch language:', error);
+                }
             }
         }
     }, [switchLanguage]);
diff --git a/src/components/layout/footer/LanguageSettings.tsx b/src/components/layout/footer/LanguageSettings.tsx
index 91d815a0..49dc2253 100644
--- a/src/components/layout/footer/LanguageSettings.tsx
+++ b/src/components/layout/footer/LanguageSettings.tsx
@@ -1,6 +1,6 @@
 import { useMemo } from 'react';
 import Text from '@/components/shared_ui/text';
-import { LANGUAGES } from '@/utils/languages';
+import { FILTERED_LANGUAGES } from '@/utils/languages';
 import { useTranslations } from '@deriv-com/translations';
 import { Tooltip } from '@deriv-com/ui';
 
@@ -12,7 +12,7 @@ const LanguageSettings = ({ openLanguageSettingModal }: TLanguageSettings) => {
     const { currentLang, localize } = useTranslations();
 
     const countryIcon = useMemo(
-        () => LANGUAGES.find(({ code }: { code: string }) => code == currentLang)?.placeholderIcon,
+        () => FILTERED_LANGUAGES.find(({ code }: { code: string }) => code == currentLang)?.placeholderIcon,
         [currentLang]
     );
 
@@ -22,6 +22,9 @@ const LanguageSettings = ({ openLanguageSettingModal }: TLanguageSettings) => {
             className='app-footer__language'
             onClick={openLanguageSettingModal}
             tooltipContent={localize('Language')}
+            aria-label={`${localize('Change language')} - ${localize('Current language')}: ${currentLang}`}
+            aria-expanded='false'
+            aria-haspopup='dialog'
         >
             {countryIcon}
             <Text size='xs' weight='bold'>
diff --git a/src/components/layout/footer/index.tsx b/src/components/layout/footer/index.tsx
index 59e8989c..3464d064 100644
--- a/src/components/layout/footer/index.tsx
+++ b/src/components/layout/footer/index.tsx
@@ -35,10 +35,17 @@ const Footer = () => {
                     languages={FILTERED_LANGUAGES}
                     onClose={hideModal}
                     onLanguageSwitch={code => {
-                        switchLanguage(code);
-                        hideModal();
-                        window.location.replace(getActiveTabUrl());
-                        window.location.reload();
+                        try {
+                            switchLanguage(code);
+                            hideModal();
+                            // Page reload is necessary because Blockly is outside React lifecycle
+                            // and won't re-render with new language without full page refresh
+                            window.location.replace(getActiveTabUrl());
+                            window.location.reload();
+                        } catch (error) {
+                            console.error('Failed to switch language:', error);
+                            hideModal();
+                        }
                     }}
                     selectedLanguage={currentLang}
                 />
diff --git a/src/components/layout/header/mobile-menu/menu-header.tsx b/src/components/layout/header/mobile-menu/menu-header.tsx
index 50aa16cf..223a2316 100644
--- a/src/components/layout/header/mobile-menu/menu-header.tsx
+++ b/src/components/layout/header/mobile-menu/menu-header.tsx
@@ -24,7 +24,13 @@ const MenuHeader = ({ hideLanguageSetting, openLanguageSetting }: TMenuHeader) =
             </Text>
 
             {!hideLanguageSetting && (
-                <button className='mobile-menu__header__language items-center' onClick={openLanguageSetting}>
+                <button
+                    className='mobile-menu__header__language items-center'
+                    onClick={openLanguageSetting}
+                    aria-label={`${localize('Change language')} - ${localize('Current language')}: ${currentLang}`}
+                    aria-expanded='false'
+                    aria-haspopup='menu'
+                >
                     {countryIcon}
                     <Text className='ml-[0.4rem]' size={isDesktop ? 'xs' : 'sm'} weight='bold'>
                         {currentLang}
diff --git a/src/components/layout/header/mobile-menu/mobile-menu.tsx b/src/components/layout/header/mobile-menu/mobile-menu.tsx
index e488fb24..34a30aba 100644
--- a/src/components/layout/header/mobile-menu/mobile-menu.tsx
+++ b/src/components/layout/header/mobile-menu/mobile-menu.tsx
@@ -62,10 +62,17 @@ const MobileMenu = ({ onLogout }: TMobileMenuProps) => {
                                 languages={FILTERED_LANGUAGES}
                                 onClose={hideModal}
                                 onLanguageSwitch={code => {
-                                    switchLanguage(code);
-                                    hideModal();
-                                    window.location.replace(getActiveTabUrl());
-                                    window.location.reload();
+                                    try {
+                                        switchLanguage(code);
+                                        hideModal();
+                                        // Page reload is necessary because Blockly is outside React lifecycle
+                                        // and won't re-render with new language without full page refresh
+                                        window.location.replace(getActiveTabUrl());
+                                        window.location.reload();
+                                    } catch (error) {
+                                        console.error('Failed to switch language:', error);
+                                        hideModal();
+                                    }
                                 }}
                                 selectedLanguage={currentLang}
                                 wrapperClassName='mobile-menu__language-drawer'

From cb1056affdfe2e5091034606403a7f17c94bd639 Mon Sep 17 00:00:00 2001
From: Rupato Braganza <rupato@deriv.com>
Date: Fri, 17 Oct 2025 17:03:09 +0800
Subject: [PATCH 5/9] fix: trigger cloudflare


From d2dce2e200b2ac21a0f228a283a8479a78e6d7ff Mon Sep 17 00:00:00 2001
From: Rupato Braganza <rupato@deriv.com>
Date: Thu, 23 Oct 2025 16:54:00 +0800
Subject: [PATCH 6/9] fix: added error map for backend messages  translation
 issues and run panel issues

---
 .../journal-components/format-message.tsx     |   6 +-
 .../__tests__/backend-error-messages.spec.ts  |  85 +++++
 src/constants/backend-error-messages.ts       | 318 ++++++++++++++++++
 src/constants/index.ts                        |  13 +
 src/external/bot-skeleton/constants/config.ts |  84 ++---
 .../blocks/Advanced/List/lists_getIndex.js    |  14 +-
 .../blocks/Advanced/List/lists_getSublist.js  |  12 +-
 .../blocks/Advanced/List/lists_indexOf.js     |   4 +-
 .../blocks/Advanced/List/lists_setIndex.js    |  14 +-
 .../blocks/Advanced/List/lists_sort.js        |   8 +-
 .../blocks/Advanced/List/lists_split.js       |   4 +-
 .../Loops/controls_flow_statements.js         |   4 +-
 .../Advanced/Loops/controls_whileUntil.js     |   4 +-
 .../blocks/Binary/Tools/Misc/console.js       |   8 +-
 .../trade_definition_contracttype.js          |   2 +-
 .../scratch/blocks/Logic/logic_boolean.js     |   4 +-
 .../scratch/blocks/Logic/logic_operation.js   |   4 +-
 .../blocks/Math/math_number_property.js       |  14 +-
 .../scratch/blocks/Math/math_on_list.js       |  18 +-
 .../scratch/blocks/Math/math_single.js        |   4 +-
 .../scratch/blocks/Text/text_changeCase.js    |   6 +-
 .../scratch/blocks/Text/text_charAt.js        |  10 +-
 .../scratch/blocks/Text/text_getSubstring.js  |  12 +-
 .../scratch/blocks/Text/text_indexOf.js       |   4 +-
 .../scratch/blocks/Text/text_prompt_ext.js    |   4 +-
 .../scratch/blocks/Text/text_trim.js          |   6 +-
 .../services/api/active-symbols.js            |   8 +-
 .../bot-skeleton/services/api/api-base.ts     |  20 +-
 .../services/tradeEngine/trade/Proposal.js    |   6 +-
 .../services/tradeEngine/trade/Purchase.js    |   2 +-
 .../services/tradeEngine/trade/Sell.js        |   3 +-
 .../services/tradeEngine/trade/Ticks.js       |   7 +-
 .../services/tradeEngine/trade/Total.js       |   6 +-
 .../services/tradeEngine/trade/index.js       |   4 +-
 .../services/tradeEngine/utils/helpers.js     |  44 +--
 src/stores/run-panel-store.ts                 |   8 +-
 src/utils/__tests__/error-handler.spec.ts     |  80 +++++
 src/utils/error-handler.ts                    | 125 +++++++
 38 files changed, 805 insertions(+), 174 deletions(-)
 create mode 100644 src/constants/__tests__/backend-error-messages.spec.ts
 create mode 100644 src/constants/backend-error-messages.ts
 create mode 100644 src/constants/index.ts
 create mode 100644 src/utils/__tests__/error-handler.spec.ts
 create mode 100644 src/utils/error-handler.ts

diff --git a/src/components/journal/journal-components/format-message.tsx b/src/components/journal/journal-components/format-message.tsx
index bbd47ac3..4fbe944f 100644
--- a/src/components/journal/journal-components/format-message.tsx
+++ b/src/components/journal/journal-components/format-message.tsx
@@ -15,11 +15,11 @@ const FormatMessage = ({ logType, className, extra }: TFormatMessageProps) => {
                 return localize('Resale of this contract is not offered.');
             }
             case LogTypes.PURCHASE: {
-                const { longcode, transaction_id } = extra;
+                const { transaction_id } = extra;
                 return (
                     <Localize
-                        i18n_default_text='<0>Bought</0>: {{longcode}} (ID: {{transaction_id}})'
-                        values={{ longcode, transaction_id }}
+                        i18n_default_text='<0>Bought</0>: Contract purchased (ID: {{transaction_id}})'
+                        values={{ transaction_id }}
                         components={[<Text key={0} size='xxs' styles={{ color: 'var(--status-info)' }} />]}
                         options={{ interpolation: { escapeValue: false } }}
                     />
diff --git a/src/constants/__tests__/backend-error-messages.spec.ts b/src/constants/__tests__/backend-error-messages.spec.ts
new file mode 100644
index 00000000..aad70a43
--- /dev/null
+++ b/src/constants/__tests__/backend-error-messages.spec.ts
@@ -0,0 +1,85 @@
+import { getBackendErrorMessages, getLocalizedErrorMessage } from '../backend-error-messages';
+
+// Mock the localize function
+jest.mock('@deriv-com/translations', () => ({
+    localize: jest.fn((message, params) => {
+        // Simple mock that replaces {{param}} with actual values
+        let result = message;
+        if (params) {
+            Object.keys(params).forEach(key => {
+                result = result.replace(new RegExp(`{{${key}}}`, 'g'), params[key]);
+            });
+        }
+        return result;
+    }),
+}));
+
+describe('Backend Error Messages', () => {
+    describe('getBackendErrorMessages', () => {
+        it('should return all error message mappings', () => {
+            const errorMessages = getBackendErrorMessages();
+
+            // Test that we have the main backend errors
+            expect(errorMessages.AccountBalanceExceedsLimit).toBeDefined();
+            expect(errorMessages.InsufficientBalance).toBeDefined();
+            expect(errorMessages.InvalidContractType).toBeDefined();
+
+            // Test that we have bot-skeleton specific errors
+            expect(errorMessages.RateLimit).toBeDefined();
+            expect(errorMessages.NotInitialized).toBeDefined();
+            expect(errorMessages.ProposalsNotReady).toBeDefined();
+        });
+
+        it('should have all original backend error codes', () => {
+            const errorMessages = getBackendErrorMessages();
+            const originalErrorCodes = [
+                'AccountBalanceExceedsLimit',
+                'AlreadyExpired',
+                'AuthorizationRequired',
+                'BarrierNotAllowed',
+                'InsufficientBalance',
+                'InvalidContractType',
+                'MarketIsClosed',
+                'PriceMoved',
+                'RateLimitExceeded',
+                'TradingDisabled',
+            ];
+
+            originalErrorCodes.forEach(code => {
+                expect(errorMessages[code as keyof typeof errorMessages]).toBeDefined();
+            });
+        });
+    });
+
+    describe('getLocalizedErrorMessage', () => {
+        it('should return localized message for known error code', () => {
+            const message = getLocalizedErrorMessage('InsufficientBalance');
+            expect(message).toContain('insufficient');
+        });
+
+        it('should handle parameters correctly', () => {
+            const message = getLocalizedErrorMessage('AccountBalanceExceedsLimit', {
+                _1: '1000 USD',
+                _2: '500 USD',
+            });
+            expect(message).toContain('1000 USD');
+            expect(message).toContain('500 USD');
+        });
+
+        it('should return fallback message for unknown error code', () => {
+            const message = getLocalizedErrorMessage('UnknownErrorCode');
+            expect(message).toBe('An error occurred. Please try again.');
+        });
+
+        it('should handle bot-skeleton specific errors', () => {
+            const message = getLocalizedErrorMessage('RateLimit', {
+                message_type: 'buy',
+                delay: '5',
+                request: '12345',
+            });
+            expect(message).toContain('buy');
+            expect(message).toContain('5');
+            expect(message).toContain('12345');
+        });
+    });
+});
diff --git a/src/constants/backend-error-messages.ts b/src/constants/backend-error-messages.ts
new file mode 100644
index 00000000..1daa96cb
--- /dev/null
+++ b/src/constants/backend-error-messages.ts
@@ -0,0 +1,318 @@
+import { localize } from '@deriv-com/translations';
+
+/**
+ * Converts backend parameter format [_1], [_2] to frontend format and maps parameters
+ * @param message - The backend error message
+ * @param details - The error details containing parameter values
+ * @returns Processed parameters object
+ */
+const processBackendParameters = (message: string, details?: Record<string, any>) => {
+    if (!details) return {};
+
+    const params: Record<string, any> = {};
+
+    // Handle common parameter mappings from backend error message format
+    if (details._1 !== undefined) params.param1 = details._1;
+    if (details._2 !== undefined) params.param2 = details._2;
+    if (details._3 !== undefined) params.param3 = details._3;
+    if (details._4 !== undefined) params.param4 = details._4;
+    if (details._5 !== undefined) params.param5 = details._5;
+
+    // Also include any named parameters from details
+    Object.keys(details).forEach(key => {
+        if (!key.startsWith('_')) {
+            params[key] = details[key];
+        }
+    });
+
+    return params;
+};
+
+// Backend error code mappings for localization
+export const getBackendErrorMessages = () => ({
+    // Bot-skeleton specific errors
+    RateLimit: localize('You are rate limited for: {{message_type}}, retrying in {{delay}}s (ID: {{request}})'),
+    DisconnectError: localize('You are disconnected, retrying in {{delay}}s'),
+    RequestFailed: localize('Request failed for: {{message_type}}, retrying in {{delay}}s'),
+    InputValidationFailed: localize('Invalid input provided'),
+    DurationValidationFailed: localize('Duration must be a positive integer'),
+    AmountValidationFailed: localize('Amount must be a positive number.'),
+    ProposalsNotReady: localize('Proposals are not ready'),
+    SelectedProposalNotExist: localize('Selected proposal does not exist'),
+    ContractBuyValidationError: localize('Contract purchase validation failed'),
+    InvalidOfferings: localize('Contract cannot be sold at this time'),
+    InvalidSellContractProposal: localize('Invalid sell contract proposal'),
+    UnrecognisedRequest: localize('Unrecognised request'),
+    InvalidContractProposal: localize('Invalid contract proposal'),
+    NotInitialized: localize('Bot.init is not called'),
+    CallError: localize('API call error occurred'),
+    WrongResponse: localize('Unexpected API response'),
+    GetProposalFailure: localize('Failed to get proposal'),
+    PositiveIntegerExpected: localize('A positive integer is expected'),
+    OptionError: localize('Option validation error occurred'),
+    LoginError: localize('Please log in to continue'),
+    CandleExpected: localize('A valid candle is expected'),
+    CandleListExpected: localize('A valid candle list is expected'),
+    CustomLimitsReached: localize('Custom trading limits have been reached'),
+    AlreadySubscribed: localize('Already subscribed to this data stream'),
+    MaxTradesReached: localize('Maximum number of trades reached'),
+    MaxLossReached: localize('Maximum loss amount reached'),
+
+    // Backend API errors
+    AccountBalanceExceedsLimit: localize(
+        'Sorry, your account cash balance is too high ({{param1}}). Your maximum account balance is {{param2}}.'
+    ),
+    AlreadyExpired: localize('This contract has already expired.'),
+    AuthorizationRequired: localize('Please log in.'),
+    BarrierNotAllowed: localize('Barrier is not allowed for this contract type.'),
+    BarrierNotInRange: localize('Barrier is not an integer in range of {{param1}} to {{param2}}.'),
+    BarrierOutOfRange: localize('Barrier is out of acceptable range.'),
+    BarrierValidationError: localize('Barrier can only be up to {{param1}} decimal places.'),
+    BetExpired: localize('The contract has expired.'),
+    CancelIsBetter: localize(
+        'The spot price has moved. We have not closed this contract because your profit is negative and deal cancellation is active. Cancel your contract to get your full stake back.'
+    ),
+    CannotCancelContract: localize('Deal cancellation is not available for this contract.'),
+    CannotValidateContract: localize('Cannot validate contract.'),
+    ClientContractProfitLimitExceeded: localize('Maximum daily profit limit exceeded for this contract.'),
+    ClientUnderlyingVolumeLimitReached: localize(
+        'You will exceed the maximum exposure limit for this market if you purchase this contract. Please close some of your positions and try again.'
+    ),
+    ClientUnwelcome: localize('Sorry, your account is not authorised for any further contract purchases.'),
+    ClientVolumeLimitReached: localize(
+        'You will exceed the maximum exposure limit if you purchase this contract. Please close some of your positions and try again.'
+    ),
+    CompanyWideLimitExceeded: localize(
+        'No further trading is allowed on this contract type for the current trading session For more info, refer to our terms and conditions.'
+    ),
+    ContractAlreadySold: localize('This contract has been sold.'),
+    ContractAlreadyStarted: localize('Start time is in the past.'),
+    ContractExpiryNotAllowed: localize('Contract may not expire between {{param1}} and {{param2}}.'),
+    ContractNotFound: localize('This contract was not found among your open positions.'),
+    ContractUpdateDisabled: localize('Update of stop loss and take profit is not available at the moment.'),
+    ContractUpdateFailure: localize('Invalid contract update parameters.'),
+    ContractUpdateNotAllowed: localize(
+        "This contract cannot be updated once you've made your purchase. This feature is not available for this contract type."
+    ),
+    ContractUpdateTooFrequent: localize('Only one update per second is allowed.'),
+    CrossMarketIntraday: localize('Intraday contracts may not cross market open.'),
+    DailyProfitLimitExceeded: localize('No further trading is allowed for the current trading session.'),
+    DailyTurnoverLimitExceeded: localize(
+        'Purchasing this contract will cause you to exceed your daily turnover limit of {{param1}} {{param2}}.'
+    ),
+    DealCancellationBlackout: localize('Deal cancellation is not available from {{param1}} to {{param2}}.'),
+    DealCancellationExpired: localize(
+        'Deal cancellation period has expired. Your contract can only be cancelled while deal cancellation is active.'
+    ),
+    DealCancellationNotAvailable: localize('Deal cancellation is not available for this asset.'),
+    DealCancellationNotBought: localize(
+        'This contract does not include deal cancellation. Your contract can only be cancelled when you select deal cancellation in your purchase.'
+    ),
+    DigitOutOfRange: localize('Digit must be in the range of {{param1}} to {{param2}}.'),
+    DuplicateExpiry: localize('Please enter only {{param1}} or {{param2}}.'),
+    EitherStopLossOrCancel: localize(
+        'You may use either stop loss or deal cancellation, but not both. Please select either one.'
+    ),
+    EitherTakeProfitOrCancel: localize(
+        'You may use either take profit or deal cancellation, but not both. Please select either one.'
+    ),
+    EntryTickMissing: localize('Waiting for entry tick.'),
+    FutureStartTime: localize('Start time is in the future.'),
+    GeneralError: localize('A general error has occurred.'),
+    GrowthRateOutOfRange: localize('Growth rate is not in acceptable range. Accepts {{param1}}.'),
+    IncorrectBarrierOffsetDecimals: localize(
+        '{{param1}} barrier offset can not have more than {{param2}} decimal places.'
+    ),
+    IncorrectPayoutDecimals: localize('Payout can not have more than {{param1}} decimal places.'),
+    IncorrectStakeDecimals: localize('Stake can not have more than {{param1}} decimal places.'),
+    InsufficientBalance: localize('Your account balance is insufficient to buy this contract.'),
+    IntegerBarrierRequired: localize('Barrier must be an integer.'),
+    IntegerSelectedTickRequired: localize('Selected tick must be an integer.'),
+    InternalServerError: localize('Sorry, an error occurred while processing your request.'),
+    InvalidAmount: localize('Amount provided can not have more than {{param1}} decimal places.'),
+    InvalidBarrier: localize('Invalid barrier.'),
+    InvalidBarrierDifferentType: localize(
+        'Invalid barrier (Barrier type must be the same for double-barrier contracts).'
+    ),
+    InvalidBarrierDouble: localize('Invalid barrier (Double barrier input is expected).'),
+    InvalidBarrierForSpot: localize('Barrier must be at least {{param1}} away from the spot.'),
+    InvalidBarrierMixedBarrier: localize('Invalid barrier (Contract can have only one type of barrier).'),
+    InvalidBarrierRange: localize('Barriers must be on either side of the spot.'),
+    InvalidBarrierSingle: localize('Invalid barrier (Single barrier input is expected).'),
+    InvalidBarrierUndef: localize('Invalid barrier.'),
+    InvalidContractType: localize('Invalid contract type.'),
+    InvalidDatePricing: localize('This contract cannot be properly validated at this time.'),
+    InvalidDealCancellation: localize('Deal cancellation is not offered at this duration.'),
+    InvalidExpiry: localize('Invalid input (duration or date_expiry) for this contract type ({{param1}}).'),
+    InvalidExpiryTime: localize('Invalid expiry time.'),
+    InvalidHighBarrier: localize('High barrier must be higher than low barrier.'),
+    InvalidHighLowBarrierRange: localize('High barrier is out of acceptable range. Please adjust the high barrier.'),
+    InvalidInput: localize('{{param1}} is not a valid input for contract type {{param2}}.'),
+    InvalidInputAsset: localize('Trading is not offered for this asset.'),
+    InvalidLowBarrierRange: localize('Low barrier is out of acceptable range. Please adjust the low barrier.'),
+    InvalidMinStake: localize("Please enter a stake amount that's at least {{param1}}."),
+    InvalidNonBinaryPrice: localize('Contract price cannot be zero.'),
+    InvalidPayoutCurrency: localize('Invalid payout currency'),
+    InvalidPrice: localize('Price provided can not have more than {{param1}} decimal places.'),
+    InvalidRequest: localize('Invalid request.'),
+    InvalidStake: localize('Invalid stake/payout.'),
+    InvalidStakeMoreThanPrice: localize("Contract's stake amount is more than the maximum purchase price."),
+    InvalidStartEnd: localize('Start time {{param1}} must be before end time {{param2}}'),
+    InvalidStopOut: localize(
+        'Invalid stop out. Stop out must be {{param1}} than current spot price. Please adjust stake or multiplier.'
+    ),
+    InvalidStyle: localize('Invalid style.'),
+    InvalidSymbol: localize('Invalid symbol.'),
+    InvalidTickExpiry: localize('Invalid duration (tick) for contract type ({{param1}}).'),
+    InvalidUpdateArgument: localize('Only a hash reference input is accepted.'),
+    InvalidUpdateValue: localize('Please enter a number or a null value.'),
+    InvalidVolatility: localize('We could not process this contract at this time.'),
+    LimitOrderAmountTooHigh: localize('Enter an amount equal to or lower than {{param1}}.'),
+    LimitOrderAmountTooLow: localize('Enter an amount equal to or higher than {{param1}}.'),
+    LimitOrderIncorrectDecimal: localize('Only {{param1}} decimal places allowed.'),
+    MarketIsClosed: localize('This market is presently closed. Market will open at {{param1}}.'),
+    MaxAggregateOpenStakeExceeded: localize(
+        'No further trading is allowed on this growth rate and instrument. Please try again later or alternatively try on other instrument or growth rate.'
+    ),
+    MissingBasisSpot: localize('Basis spot is not defined.'),
+    MissingConfig: localize('Missing configuration for {{param1}} and {{param2}} with expiry type {{param3}}'),
+    MissingContractId: localize('Contract id is required.'),
+    MissingEither: localize('Please specify either {{param1}} or {{param2}}.'),
+    MissingMarketData: localize('Trading is suspended due to missing market data.'),
+    MissingRequiredContractConfig: localize('Missing required contract config.'),
+    MissingRequiredContractParams: localize('Missing required contract parameters ({{param1}}).'),
+    MissingRequiredDigit: localize('Missing required contract parameters (last digit prediction for digit contracts).'),
+    MissingRequiredSelectedTick: localize('Missing required contract parameters (selected tick).'),
+    MissingSpotMarketData: localize('Trading is suspended due to missing market (spot too far) data.'),
+    MissingTickMarketData: localize('Trading is suspended due to missing market (tick) data.'),
+    MissingVanillaFinancialConfig: localize('Missing vanilla option configuration for financial symbols'),
+    MissingVolatilityMarketData: localize('Trading is suspended due to missing market (volatility) data.'),
+    MultiplierOutOfRange: localize('Multiplier is not in acceptable range. Accepts {{param1}}.'),
+    MultiplierRangeDisabled: localize('Multiplier is not in acceptable range.'),
+    NeedAbsoluteBarrier: localize('Contracts more than 24 hours in duration would need an absolute barrier.'),
+    NegativeContractBarrier: localize(
+        'Barrier offset {{param1}} exceeded quote price, contract barrier must be positive.'
+    ),
+    NegativeTakeProfit: localize('Negative take profit value is not accepted'),
+    NoBusiness: localize('This contract is unavailable on this account.'),
+    NoBusinessMultiplier: localize(
+        'Trading multiplier options on {{param1}} is disabled. Please choose another market.'
+    ),
+    NoCurrencySet: localize('Please set the currency of your account.'),
+    NoOpenPosition: localize('This contract was not found among your open positions.'),
+    NoReturn: localize('This contract offers no return.'),
+    NonDeterminedBarriers: localize('Barriers could not be determined.'),
+    NotDefaultCurrency: localize('The provided currency {{param1}} is not the default currency.'),
+    OfferingsInvalidSymbol: localize("There's no contract available for this symbol."),
+    OfferingsSymbolRequired: localize('Symbol is required.'),
+    OldMarketData: localize('Trading is suspended due to missing market (old) data.'),
+    OpenPositionLimit: localize(
+        'Sorry, you cannot hold more than {{param1}} contracts at a given time. Please wait until some contracts have closed and try again.'
+    ),
+    OpenPositionLimitExceeded: localize('You have too many open positions for this contract type.'),
+    OpenPositionPayoutLimit: localize(
+        'Sorry, the aggregate payouts of contracts on your account cannot exceed {{param1}} {{param2}}.'
+    ),
+    OrderUpdateNotAllowed: localize('Only updates to these parameters are allowed {{param1}}.'),
+    OutdatedVolatilityData: localize('Trading is suspended due to missing market (out-of-date volatility) data.'),
+    PastExpiryTime: localize('Expiry time cannot be in the past.'),
+    PastStartTime: localize('Start time is in the past.'),
+    PayoutLimitExceeded: localize('This contract is limited to {{param1}} payout on this account.'),
+    PayoutLimits: localize(
+        'Minimum stake of {{param1}} and maximum payout of {{param2}}. Current payout is {{param3}}.'
+    ),
+    PermissionDenied: localize('Permission denied.'),
+    PriceMoved: localize(
+        'The underlying market has moved too much since you priced the contract. The contract {{param4}} has changed from {{param2}} {{param1}} to {{param3}} {{param1}}.'
+    ),
+    ProductSpecificTurnoverLimitExceeded: localize(
+        "You've reached the maximum daily stake for this trade type. Choose another trade type, or wait until {{param1}} {{param2}} {{param3}} {{param4}} {{param5}} UTC tomorrow for the daily limit to reset."
+    ),
+    PromoCodeLimitExceeded: localize(
+        'Your account has exceeded the trading limit with free promo code, please deposit if you wish to continue trading.'
+    ),
+    RateLimitExceeded: localize('Rate limit exceeded.'),
+    RefundBuyForMissingData: localize(
+        'There was a market data disruption during the contract period. For real-money accounts we will attempt to correct this and settle the contract properly, otherwise the contract will be cancelled and refunded. Virtual-money contracts will be cancelled and refunded.'
+    ),
+    ResaleNotOffered: localize('Resale of this contract is not offered.'),
+    ResaleNotOfferedHolidays: localize(
+        'Resale of this contract is not offered due to market holidays during contract period.'
+    ),
+    ResalePathDependentNotAllowed: localize('Resale not available during rollover time.'),
+    ResetBarrierError: localize('Non atm barrier is not allowed for reset contract.'),
+    ResetFixedExpiryError: localize('Fixed expiry for reset contract is not allowed.'),
+    RoundingExceedPermittedEpsilon: localize('Only a maximum of two decimal points are allowed for the amount.'),
+    SameBarriersNotAllowed: localize('High and low barriers must be different.'),
+    SameExpiryStartTime: localize('Expiry time cannot be equal to start time.'),
+    SameStartSellTime: localize('Contract cannot be sold at this time. Please try again.'),
+    SameTradingDayExpiry: localize(
+        'Contracts on this market with a duration of under 24 hours must expire on the same trading day.'
+    ),
+    SelectedTickNumberLimits: localize('Tick prediction must be between {{param1}} and {{param2}}.'),
+    SellAtEntryTick: localize('Contract cannot be sold at entry tick. Please wait for the next tick.'),
+    SellFailureDueToUpdate: localize('Sell failed because contract was updated.'),
+    SellPriceLowerThanStake: localize('Sell price must be higher than stake {{param1}}.'),
+    SpecificOpenPositionLimitExceeded: localize(
+        'You have exceeded the open position limit for contracts of this type.'
+    ),
+    StakeLimitExceeded: localize('Maximum stake allowed is {{param1}}.'),
+    StakeLimits: localize('Minimum stake of {{param1}} and maximum payout of {{param2}}. Current stake is {{param3}}.'),
+    StakeTooLow: localize(
+        "This contract's price is {{param2}} {{param1}}. Contracts purchased from {{param3}} must have a purchase price above {{param4}} {{param1}}. Please accordingly increase the contract amount to meet this minimum stake."
+    ),
+    Suspendedlogin: localize(
+        "We can't take you to your account right now due to system maintenance. Please try again later."
+    ),
+    SymbolMissingInBetMarketTable: localize('Trading is suspended for this instrument.'),
+    TicksNumberLimits: localize('Number of ticks must be between {{param1}} and {{param2}}.'),
+    TooManyHolidays: localize('Too many market holidays during the contract period.'),
+    TradeTemporarilyUnavailable: localize('This trade is temporarily unavailable.'),
+    TradingConfigError: localize('Sorry, an error occurred while processing your request.'),
+    TradingDayEndExpiry: localize(
+        'Contracts on this market with a duration of more than 24 hours must expire at the end of a trading day.'
+    ),
+    TradingDayExpiry: localize('The contract must expire on a trading day.'),
+    TradingDisabled: localize('Trading is disabled for this account.'),
+    TradingDurationNotAllowed: localize('Trading is not offered for this duration.'),
+    TradingHoursExpiry: localize('Contract must expire during trading hours.'),
+    TradingNotAvailable: localize('Trading is not available from {{param1}} to {{param2}}.'),
+    TradingSuspendedSpecificHours: localize(
+        'Trading on forex contracts with duration less than 5 hours is not available from {{param1}} to {{param2}}'
+    ),
+    TransactionTimeTooOld: localize('Cannot create contract.'),
+    TransactionTimeTooYoung: localize('Cannot create contract.'),
+    UpdateStopLossNotAllowed: localize('You may update your stop loss amount after deal cancellation has expired.'),
+    UpdateTakeProfitNotAllowed: localize('You may update your take profit amount after deal cancellation has expired.'),
+    WaitForContractSettlement: localize(
+        'Please wait for contract settlement. The final settlement price may differ from the indicative price.'
+    ),
+    WrongAmountTypeOne: localize('Basis must be {{param1}} for this contract.'),
+    WrongAmountTypeTwo: localize('Basis can either be {{param1}} or {{param2}} for this contract.'),
+    ZeroAbsoluteBarrier: localize('Barrier cannot be zero.'),
+});
+
+/**
+ * Helper function to get localized error message by error code
+ * @param errorCode - The backend error code
+ * @param details - Optional error details containing parameter values
+ * @returns Localized error message
+ */
+export const getLocalizedErrorMessage = (errorCode: string, details?: Record<string, any>): string => {
+    const errorMessages = getBackendErrorMessages();
+    const message = errorMessages[errorCode as keyof typeof errorMessages];
+
+    if (!message) {
+        // Fallback to a generic error message if the error code is not found
+        return localize('An error occurred. Please try again.');
+    }
+
+    // Process backend parameters and pass them to localize
+    const processedParams = processBackendParameters(message, details);
+    return localize(message, processedParams);
+};
+
+/**
+ * Type definition for backend error codes
+ */
+export type BackendErrorCode = keyof ReturnType<typeof getBackendErrorMessages>;
diff --git a/src/constants/index.ts b/src/constants/index.ts
new file mode 100644
index 00000000..fee9a7c2
--- /dev/null
+++ b/src/constants/index.ts
@@ -0,0 +1,13 @@
+export * from './backend-error-messages';
+export * from './bot-version';
+export * from './button-status';
+export * from './contract';
+export * from './contract-stage';
+export * from './dashboard';
+export * from './run-panel';
+export * from './transactions';
+export * from './z-indexes';
+
+// Export specific items to avoid conflicts
+export { tabs_title as bot_contents_tabs_title } from './bot-contents';
+export { tabs_title as load_modal_tabs_title } from './load-modal';
diff --git a/src/external/bot-skeleton/constants/config.ts b/src/external/bot-skeleton/constants/config.ts
index 1c029eb7..c83117b0 100644
--- a/src/external/bot-skeleton/constants/config.ts
+++ b/src/external/bot-skeleton/constants/config.ts
@@ -54,127 +54,127 @@ export const config = () => ({
     opposites: {
         ACCUMULATOR: [
             {
-                ACCU: localize('Buy'),
+                ACCU: 'Buy',
             },
         ],
         MULTIPLIER: [
             {
-                MULTUP: localize('Up'),
+                MULTUP: 'Up',
             },
             {
-                MULTDOWN: localize('Down'),
+                MULTDOWN: 'Down',
             },
         ],
         CALLPUT: [
             {
-                CALL: localize('Rise'),
+                CALL: 'Rise',
             },
             {
-                PUT: localize('Fall'),
+                PUT: 'Fall',
             },
         ],
         CALLPUTEQUAL: [
             {
-                CALLE: localize('Rise Equals'),
+                CALLE: 'Rise Equals',
             },
             {
-                PUTE: localize('Fall Equals'),
+                PUTE: 'Fall Equals',
             },
         ],
         HIGHERLOWER: [
             {
-                CALL: localize('Higher'),
+                CALL: 'Higher',
             },
             {
-                PUT: localize('Lower'),
+                PUT: 'Lower',
             },
         ],
         TOUCHNOTOUCH: [
             {
-                ONETOUCH: localize('Touch'),
+                ONETOUCH: 'Touch',
             },
             {
-                NOTOUCH: localize('No Touch'),
+                NOTOUCH: 'No Touch',
             },
         ],
         ENDSINOUT: [
             {
-                EXPIRYRANGE: localize('Ends Between'),
+                EXPIRYRANGE: 'Ends Between',
             },
             {
-                EXPIRYMISS: localize('Ends Outside'),
+                EXPIRYMISS: 'Ends Outside',
             },
         ],
         STAYSINOUT: [
             {
-                RANGE: localize('Stays Between'),
+                RANGE: 'Stays Between',
             },
             {
-                UPORDOWN: localize('Goes Outside'),
+                UPORDOWN: 'Goes Outside',
             },
         ],
         ASIANS: [
             {
-                ASIANU: localize('Asian Up'),
+                ASIANU: 'Asian Up',
             },
             {
-                ASIAND: localize('Asian Down'),
+                ASIAND: 'Asian Down',
             },
         ],
         MATCHESDIFFERS: [
             {
-                DIGITMATCH: localize('Matches'),
+                DIGITMATCH: 'Matches',
             },
             {
-                DIGITDIFF: localize('Differs'),
+                DIGITDIFF: 'Differs',
             },
         ],
         EVENODD: [
             {
-                DIGITEVEN: localize('Even'),
+                DIGITEVEN: 'Even',
             },
             {
-                DIGITODD: localize('Odd'),
+                DIGITODD: 'Odd',
             },
         ],
         OVERUNDER: [
             {
-                DIGITOVER: localize('Over'),
+                DIGITOVER: 'Over',
             },
             {
-                DIGITUNDER: localize('Under'),
+                DIGITUNDER: 'Under',
             },
         ],
         HIGHLOWTICKS: [
             {
-                TICKHIGH: localize('High Tick'),
+                TICKHIGH: 'High Tick',
             },
             {
-                TICKLOW: localize('Low Tick'),
+                TICKLOW: 'Low Tick',
             },
         ],
         RESET: [
             {
-                RESETCALL: localize('Reset Call'),
+                RESETCALL: 'Reset Call',
             },
             {
-                RESETPUT: localize('Reset Put'),
+                RESETPUT: 'Reset Put',
             },
         ],
         RUNS: [
             {
-                RUNHIGH: localize('Only Ups'),
+                RUNHIGH: 'Only Ups',
             },
             {
-                RUNLOW: localize('Only Downs'),
+                RUNLOW: 'Only Downs',
             },
         ],
         CALLPUTSPREAD: [
             {
-                CALLSPREAD: localize('Call Spread'),
+                CALLSPREAD: 'Call Spread',
             },
             {
-                PUTSPREAD: localize('Put Spread'),
+                PUTSPREAD: 'Put Spread',
             },
         ],
     },
@@ -227,17 +227,17 @@ export const config = () => ({
         accumulator: ['accumulator'],
     },
     TRADE_TYPE_CATEGORY_NAMES: {
-        callput: localize('Up/Down'),
-        touchnotouch: localize('Touch/No Touch'),
-        inout: localize('In/Out'),
-        asian: localize('Asians'),
-        digits: localize('Digits'),
-        reset: localize('Reset Call/Reset Put'),
-        callputspread: localize('Call Spread/Put Spread'),
-        highlowticks: localize('High/Low Ticks'),
-        runs: localize('Only Ups/Only Downs'),
-        multiplier: localize('Multipliers'),
-        accumulator: localize('Accumulators'),
+        callput: 'Up/Down',
+        touchnotouch: 'Touch/No Touch',
+        inout: 'In/Out',
+        asian: 'Asians',
+        digits: 'Digits',
+        reset: 'Reset Call/Reset Put',
+        callputspread: 'Call Spread/Put Spread',
+        highlowticks: 'High/Low Ticks',
+        runs: 'Only Ups/Only Downs',
+        multiplier: 'Multipliers',
+        accumulator: 'Accumulators',
     },
     BARRIER_CATEGORIES: {
         euro_atm: ['callput', 'callputequal'],
diff --git a/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_getIndex.js b/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_getIndex.js
index 6cc729cd..92e1ecd2 100755
--- a/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_getIndex.js
+++ b/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_getIndex.js
@@ -4,16 +4,16 @@ import { modifyContextMenu } from '../../../utils';
 window.Blockly.Blocks.lists_getIndex = {
     init() {
         this.MODE_OPTIONS = [
-            [localize('get'), 'GET'],
-            [localize('get and remove'), 'GET_REMOVE'],
-            [localize('remove'), 'REMOVE'],
+            ['get', 'GET'],
+            ['get and remove', 'GET_REMOVE'],
+            ['remove', 'REMOVE'],
         ];
         this.WHERE_OPTIONS = [
             ['#', 'FROM_START'],
-            [localize('# from end'), 'FROM_END'],
-            [localize('first'), 'FIRST'],
-            [localize('last'), 'LAST'],
-            [localize('random'), 'RANDOM'],
+            ['# from end', 'FROM_END'],
+            ['first', 'FIRST'],
+            ['last', 'LAST'],
+            ['random', 'RANDOM'],
         ];
         const modeMenu = new window.Blockly.FieldDropdown(this.MODE_OPTIONS, value => {
             const isStatement = value === 'REMOVE';
diff --git a/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_getSublist.js b/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_getSublist.js
index 13a6070a..38d7e003 100755
--- a/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_getSublist.js
+++ b/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_getSublist.js
@@ -4,14 +4,14 @@ import { modifyContextMenu } from '../../../utils';
 window.Blockly.Blocks.lists_getSublist = {
     init() {
         this.WHERE_OPTIONS_1 = [
-            [localize('get sub-list from #'), 'FROM_START'],
-            [localize('get sub-list from # from end'), 'FROM_END'],
-            [localize('get sub-list from first'), 'FIRST'],
+            ['get sub-list from #', 'FROM_START'],
+            ['get sub-list from # from end', 'FROM_END'],
+            ['get sub-list from first', 'FIRST'],
         ];
         this.WHERE_OPTIONS_2 = [
-            [localize('#'), 'FROM_START'],
-            [localize('# from end'), 'FROM_END'],
-            [localize('last'), 'LAST'],
+            ['#', 'FROM_START'],
+            ['# from end', 'FROM_END'],
+            ['last', 'LAST'],
         ];
 
         this.appendValueInput('LIST').appendField(localize('in list'));
diff --git a/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_indexOf.js b/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_indexOf.js
index 9c57671d..2e0994d0 100755
--- a/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_indexOf.js
+++ b/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_indexOf.js
@@ -24,8 +24,8 @@ window.Blockly.Blocks.lists_indexOf = {
                     type: 'field_dropdown',
                     name: 'END',
                     options: [
-                        [localize('first'), 'FIRST'],
-                        [localize('last'), 'LAST'],
+                        ['first', 'FIRST'],
+                        ['last', 'LAST'],
                     ],
                 },
                 {
diff --git a/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_setIndex.js b/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_setIndex.js
index 1fa09482..b219defc 100755
--- a/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_setIndex.js
+++ b/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_setIndex.js
@@ -4,15 +4,15 @@ import { modifyContextMenu } from '../../../utils';
 window.Blockly.Blocks.lists_setIndex = {
     init() {
         this.MODE_OPTIONS = [
-            [localize('set'), 'SET'],
-            [localize('insert at'), 'INSERT'],
+            ['set', 'SET'],
+            ['insert at', 'INSERT'],
         ];
         this.WHERE_OPTIONS = [
-            [localize('#'), 'FROM_START'],
-            [localize('# from end'), 'FROM_END'],
-            [localize('first'), 'FIRST'],
-            [localize('last'), 'LAST'],
-            [localize('random'), 'RANDOM'],
+            ['#', 'FROM_START'],
+            ['# from end', 'FROM_END'],
+            ['first', 'FIRST'],
+            ['last', 'LAST'],
+            ['random', 'RANDOM'],
         ];
 
         this.appendValueInput('LIST').setCheck('Array').appendField(localize('in list'));
diff --git a/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_sort.js b/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_sort.js
index c5dfc445..8ed6de68 100755
--- a/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_sort.js
+++ b/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_sort.js
@@ -17,16 +17,16 @@ window.Blockly.Blocks.lists_sort = {
                     type: 'field_dropdown',
                     name: 'TYPE',
                     options: [
-                        [localize('numeric'), 'NUMERIC'],
-                        [localize('alphabetic'), 'TEXT'],
+                        ['numeric', 'NUMERIC'],
+                        ['alphabetic', 'TEXT'],
                     ],
                 },
                 {
                     type: 'field_dropdown',
                     name: 'DIRECTION',
                     options: [
-                        [localize('ascending'), '1'],
-                        [localize('descending'), '-1'],
+                        ['ascending', '1'],
+                        ['descending', '-1'],
                     ],
                 },
                 {
diff --git a/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_split.js b/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_split.js
index a815a6ac..28e49e46 100755
--- a/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_split.js
+++ b/src/external/bot-skeleton/scratch/blocks/Advanced/List/lists_split.js
@@ -5,8 +5,8 @@ window.Blockly.Blocks.lists_split = {
     init() {
         const dropdown = new window.Blockly.FieldDropdown(
             [
-                [localize('make list from text'), 'SPLIT'],
-                [localize('make text from list'), 'JOIN'],
+                ['make list from text', 'SPLIT'],
+                ['make text from list', 'JOIN'],
             ],
             newMode => this.updateType(newMode)
         );
diff --git a/src/external/bot-skeleton/scratch/blocks/Advanced/Loops/controls_flow_statements.js b/src/external/bot-skeleton/scratch/blocks/Advanced/Loops/controls_flow_statements.js
index e0065ff8..158808a0 100755
--- a/src/external/bot-skeleton/scratch/blocks/Advanced/Loops/controls_flow_statements.js
+++ b/src/external/bot-skeleton/scratch/blocks/Advanced/Loops/controls_flow_statements.js
@@ -13,8 +13,8 @@ window.Blockly.Blocks.controls_flow_statements = {
                     type: 'field_dropdown',
                     name: 'FLOW',
                     options: [
-                        [localize('break out'), 'BREAK'],
-                        [localize('continue with next iteration'), 'CONTINUE'],
+                        ['break out', 'BREAK'],
+                        ['continue with next iteration', 'CONTINUE'],
                     ],
                 },
             ],
diff --git a/src/external/bot-skeleton/scratch/blocks/Advanced/Loops/controls_whileUntil.js b/src/external/bot-skeleton/scratch/blocks/Advanced/Loops/controls_whileUntil.js
index eb8af3ad..1ede4a4d 100755
--- a/src/external/bot-skeleton/scratch/blocks/Advanced/Loops/controls_whileUntil.js
+++ b/src/external/bot-skeleton/scratch/blocks/Advanced/Loops/controls_whileUntil.js
@@ -13,8 +13,8 @@ window.Blockly.Blocks.controls_whileUntil = {
                     type: 'field_dropdown',
                     name: 'MODE',
                     options: [
-                        [localize('while'), 'WHILE'],
-                        [localize('until'), 'UNTIL'],
+                        ['while', 'WHILE'],
+                        ['until', 'UNTIL'],
                     ],
                 },
                 {
diff --git a/src/external/bot-skeleton/scratch/blocks/Binary/Tools/Misc/console.js b/src/external/bot-skeleton/scratch/blocks/Binary/Tools/Misc/console.js
index 14c777bf..5feb283b 100644
--- a/src/external/bot-skeleton/scratch/blocks/Binary/Tools/Misc/console.js
+++ b/src/external/bot-skeleton/scratch/blocks/Binary/Tools/Misc/console.js
@@ -16,10 +16,10 @@ window.Blockly.Blocks.console = {
                     type: 'field_dropdown',
                     name: 'CONSOLE_TYPE',
                     options: [
-                        [localize('Log'), 'log'],
-                        [localize('Warn'), 'warn'],
-                        [localize('Error'), 'error'],
-                        [localize('Table'), 'table'],
+                        ['Log', 'log'],
+                        ['Warn', 'warn'],
+                        ['Error', 'error'],
+                        ['Table', 'table'],
                     ],
                 },
                 {
diff --git a/src/external/bot-skeleton/scratch/blocks/Binary/Trade Definition/trade_definition_contracttype.js b/src/external/bot-skeleton/scratch/blocks/Binary/Trade Definition/trade_definition_contracttype.js
index 76fa8f3c..3161e305 100755
--- a/src/external/bot-skeleton/scratch/blocks/Binary/Trade Definition/trade_definition_contracttype.js	
+++ b/src/external/bot-skeleton/scratch/blocks/Binary/Trade Definition/trade_definition_contracttype.js	
@@ -44,7 +44,7 @@ window.Blockly.Blocks.trade_definition_contracttype = {
                 const trade_types = getContractTypeOptions('both', trade_type);
 
                 if (trade_types.length > 1) {
-                    contract_type_options.push([localize('Both'), 'both']);
+                    contract_type_options.push(['Both', 'both']);
                 }
 
                 contract_type_options.push(...trade_types);
diff --git a/src/external/bot-skeleton/scratch/blocks/Logic/logic_boolean.js b/src/external/bot-skeleton/scratch/blocks/Logic/logic_boolean.js
index bb4df0fb..bde2a65e 100755
--- a/src/external/bot-skeleton/scratch/blocks/Logic/logic_boolean.js
+++ b/src/external/bot-skeleton/scratch/blocks/Logic/logic_boolean.js
@@ -13,8 +13,8 @@ window.Blockly.Blocks.logic_boolean = {
                     type: 'field_dropdown',
                     name: 'BOOL',
                     options: [
-                        [localize('true'), 'TRUE'],
-                        [localize('false'), 'FALSE'],
+                        ['true', 'TRUE'],
+                        ['false', 'FALSE'],
                     ],
                 },
             ],
diff --git a/src/external/bot-skeleton/scratch/blocks/Logic/logic_operation.js b/src/external/bot-skeleton/scratch/blocks/Logic/logic_operation.js
index 4c31e879..9e50500a 100755
--- a/src/external/bot-skeleton/scratch/blocks/Logic/logic_operation.js
+++ b/src/external/bot-skeleton/scratch/blocks/Logic/logic_operation.js
@@ -17,8 +17,8 @@ window.Blockly.Blocks.logic_operation = {
                     type: 'field_dropdown',
                     name: 'OP',
                     options: [
-                        [localize('and'), 'AND'],
-                        [localize('or'), 'OR'],
+                        ['and', 'AND'],
+                        ['or', 'OR'],
                     ],
                 },
                 {
diff --git a/src/external/bot-skeleton/scratch/blocks/Math/math_number_property.js b/src/external/bot-skeleton/scratch/blocks/Math/math_number_property.js
index 055e068e..adedba3e 100755
--- a/src/external/bot-skeleton/scratch/blocks/Math/math_number_property.js
+++ b/src/external/bot-skeleton/scratch/blocks/Math/math_number_property.js
@@ -27,13 +27,13 @@ window.Blockly.Blocks.math_number_property = {
                     type: 'field_dropdown',
                     name: 'PROPERTY',
                     options: [
-                        [localize('even'), 'EVEN'],
-                        [localize('odd'), 'ODD'],
-                        [localize('prime'), 'PRIME'],
-                        [localize('whole'), 'WHOLE'],
-                        [localize('positive'), 'POSITIVE'],
-                        [localize('negative'), 'NEGATIVE'],
-                        [localize('divisible by'), 'DIVISIBLE_BY'],
+                        ['even', 'EVEN'],
+                        ['odd', 'ODD'],
+                        ['prime', 'PRIME'],
+                        ['whole', 'WHOLE'],
+                        ['positive', 'POSITIVE'],
+                        ['negative', 'NEGATIVE'],
+                        ['divisible by', 'DIVISIBLE_BY'],
                     ],
                 },
             ],
diff --git a/src/external/bot-skeleton/scratch/blocks/Math/math_on_list.js b/src/external/bot-skeleton/scratch/blocks/Math/math_on_list.js
index 0b3318c2..d9911633 100755
--- a/src/external/bot-skeleton/scratch/blocks/Math/math_on_list.js
+++ b/src/external/bot-skeleton/scratch/blocks/Math/math_on_list.js
@@ -16,15 +16,15 @@ window.Blockly.Blocks.math_on_list = {
                     type: 'field_dropdown',
                     name: 'OP',
                     options: [
-                        [localize('sum'), 'SUM'],
-                        [localize('min'), 'MIN'],
-                        [localize('max'), 'MAX'],
-                        [localize('average'), 'AVERAGE'],
-                        [localize('median'), 'MEDIAN'],
-                        [localize('mode'), 'MODE'],
-                        [localize('antimode'), 'ANTIMODE'],
-                        [localize('standard deviation'), 'STD_DEV'],
-                        [localize('random item'), 'RANDOM'],
+                        ['sum', 'SUM'],
+                        ['min', 'MIN'],
+                        ['max', 'MAX'],
+                        ['average', 'AVERAGE'],
+                        ['median', 'MEDIAN'],
+                        ['mode', 'MODE'],
+                        ['antimode', 'ANTIMODE'],
+                        ['standard deviation', 'STD_DEV'],
+                        ['random item', 'RANDOM'],
                     ],
                 },
                 {
diff --git a/src/external/bot-skeleton/scratch/blocks/Math/math_single.js b/src/external/bot-skeleton/scratch/blocks/Math/math_single.js
index 00d324bb..d423e287 100755
--- a/src/external/bot-skeleton/scratch/blocks/Math/math_single.js
+++ b/src/external/bot-skeleton/scratch/blocks/Math/math_single.js
@@ -13,8 +13,8 @@ window.Blockly.Blocks.math_single = {
                     type: 'field_dropdown',
                     name: 'OP',
                     options: [
-                        [localize('square root'), 'ROOT'],
-                        [localize('absolute'), 'ABS'],
+                        ['square root', 'ROOT'],
+                        ['absolute', 'ABS'],
                         ['-', 'NEG'],
                         ['ln', 'LN'],
                         ['log10', 'LOG10'],
diff --git a/src/external/bot-skeleton/scratch/blocks/Text/text_changeCase.js b/src/external/bot-skeleton/scratch/blocks/Text/text_changeCase.js
index ac7c9d97..88a8f92b 100755
--- a/src/external/bot-skeleton/scratch/blocks/Text/text_changeCase.js
+++ b/src/external/bot-skeleton/scratch/blocks/Text/text_changeCase.js
@@ -20,9 +20,9 @@ window.Blockly.Blocks.text_changeCase = {
                     type: 'field_dropdown',
                     name: 'CASE',
                     options: [
-                        [localize('UPPER CASE'), 'UPPERCASE'],
-                        [localize('lower case'), 'LOWERCASE'],
-                        [localize('Title Case'), 'TITLECASE'],
+                        ['UPPER CASE', 'UPPERCASE'],
+                        ['lower case', 'LOWERCASE'],
+                        ['Title Case', 'TITLECASE'],
                     ],
                 },
             ],
diff --git a/src/external/bot-skeleton/scratch/blocks/Text/text_charAt.js b/src/external/bot-skeleton/scratch/blocks/Text/text_charAt.js
index dfad456d..19fa4d54 100755
--- a/src/external/bot-skeleton/scratch/blocks/Text/text_charAt.js
+++ b/src/external/bot-skeleton/scratch/blocks/Text/text_charAt.js
@@ -33,11 +33,11 @@ window.Blockly.Blocks.text_charAt = {
                     type: 'field_dropdown',
                     name: 'WHERE',
                     options: [
-                        [localize('letter #'), 'FROM_START'],
-                        [localize('letter # from end'), 'FROM_END'],
-                        [localize('first letter'), 'FIRST'],
-                        [localize('last letter'), 'LAST'],
-                        [localize('random letter'), 'RANDOM'],
+                        ['letter #', 'FROM_START'],
+                        ['letter # from end', 'FROM_END'],
+                        ['first letter', 'FIRST'],
+                        ['last letter', 'LAST'],
+                        ['random letter', 'RANDOM'],
                     ],
                 },
             ],
diff --git a/src/external/bot-skeleton/scratch/blocks/Text/text_getSubstring.js b/src/external/bot-skeleton/scratch/blocks/Text/text_getSubstring.js
index 1830c868..ff989390 100755
--- a/src/external/bot-skeleton/scratch/blocks/Text/text_getSubstring.js
+++ b/src/external/bot-skeleton/scratch/blocks/Text/text_getSubstring.js
@@ -4,14 +4,14 @@ import { emptyTextValidator, modifyContextMenu } from '../../utils';
 window.Blockly.Blocks.text_getSubstring = {
     init() {
         this.WHERE_OPTIONS_1 = [
-            [localize('letter #'), 'FROM_START'],
-            [localize('letter # from end'), 'FROM_END'],
-            [localize('first'), 'FIRST'],
+            ['letter #', 'FROM_START'],
+            ['letter # from end', 'FROM_END'],
+            ['first', 'FIRST'],
         ];
         this.WHERE_OPTIONS_2 = [
-            [localize('letter #'), 'FROM_START'],
-            [localize('letter # from end'), 'FROM_END'],
-            [localize('last'), 'LAST'],
+            ['letter #', 'FROM_START'],
+            ['letter # from end', 'FROM_END'],
+            ['last', 'LAST'],
         ];
 
         this.jsonInit(this.definition());
diff --git a/src/external/bot-skeleton/scratch/blocks/Text/text_indexOf.js b/src/external/bot-skeleton/scratch/blocks/Text/text_indexOf.js
index e6fcf150..a38ad1fa 100755
--- a/src/external/bot-skeleton/scratch/blocks/Text/text_indexOf.js
+++ b/src/external/bot-skeleton/scratch/blocks/Text/text_indexOf.js
@@ -24,8 +24,8 @@ window.Blockly.Blocks.text_indexOf = {
                     type: 'field_dropdown',
                     name: 'END',
                     options: [
-                        [localize('first'), 'FIRST'],
-                        [localize('last'), 'LAST'],
+                        ['first', 'FIRST'],
+                        ['last', 'LAST'],
                     ],
                 },
                 {
diff --git a/src/external/bot-skeleton/scratch/blocks/Text/text_prompt_ext.js b/src/external/bot-skeleton/scratch/blocks/Text/text_prompt_ext.js
index e589cac5..db2a9e85 100755
--- a/src/external/bot-skeleton/scratch/blocks/Text/text_prompt_ext.js
+++ b/src/external/bot-skeleton/scratch/blocks/Text/text_prompt_ext.js
@@ -30,8 +30,8 @@ window.Blockly.Blocks.text_prompt_ext = {
                     type: 'field_dropdown',
                     name: 'TYPE',
                     options: [
-                        [localize('string'), 'TEXT'],
-                        [localize('number'), 'NUMBER'],
+                        ['string', 'TEXT'],
+                        ['number', 'NUMBER'],
                     ],
                 },
                 {
diff --git a/src/external/bot-skeleton/scratch/blocks/Text/text_trim.js b/src/external/bot-skeleton/scratch/blocks/Text/text_trim.js
index bd8ae3e5..25778c64 100755
--- a/src/external/bot-skeleton/scratch/blocks/Text/text_trim.js
+++ b/src/external/bot-skeleton/scratch/blocks/Text/text_trim.js
@@ -13,9 +13,9 @@ window.Blockly.Blocks.text_trim = {
                     type: 'field_dropdown',
                     name: 'MODE',
                     options: [
-                        [localize('both sides'), 'BOTH'],
-                        [localize('left side'), 'LEFT'],
-                        [localize('right side'), 'RIGHT'],
+                        ['both sides', 'BOTH'],
+                        ['left side', 'LEFT'],
+                        ['right side', 'RIGHT'],
                     ],
                 },
                 {
diff --git a/src/external/bot-skeleton/services/api/active-symbols.js b/src/external/bot-skeleton/services/api/active-symbols.js
index 163628b3..79724c47 100644
--- a/src/external/bot-skeleton/services/api/active-symbols.js
+++ b/src/external/bot-skeleton/services/api/active-symbols.js
@@ -1,5 +1,4 @@
 /* eslint-disable no-confusing-arrow */
-import { localize } from '@deriv-com/translations';
 import {
     ACTIVE_SYMBOLS,
     MARKET_MAPPINGS,
@@ -327,8 +326,7 @@ export default class ActiveSymbols {
 
         Object.keys(this.processed_symbols).forEach(market_name => {
             const { display_name } = this.processed_symbols[market_name];
-            const market_display_name =
-                display_name + (this.isMarketClosed(market_name) ? ` ${localize('(Closed)')}` : '');
+            const market_display_name = display_name + (this.isMarketClosed(market_name) ? ' (Closed)' : '');
             market_options.push([market_display_name, market_name]);
         });
 
@@ -363,7 +361,7 @@ export default class ActiveSymbols {
             Object.keys(submarkets).forEach(submarket_name => {
                 const { display_name } = submarkets[submarket_name];
                 const submarket_display_name =
-                    display_name + (this.isSubmarketClosed(submarket_name) ? ` ${localize('(Closed)')}` : '');
+                    display_name + (this.isSubmarketClosed(submarket_name) ? ' (Closed)' : '');
                 submarket_options.push([submarket_display_name, submarket_name]);
             });
         }
@@ -430,7 +428,7 @@ export default class ActiveSymbols {
                     symbol_keys.forEach(symbol_name => {
                         const { display_name } = symbols[symbol_name];
                         const symbol_display_name =
-                            display_name + (this.isSymbolClosed(symbol_name) ? ` ${localize('(Closed)')}` : '');
+                            display_name + (this.isSymbolClosed(symbol_name) ? ' (Closed)' : '');
                         accumulator.push([symbol_display_name, symbol_name]);
                     });
                 }
diff --git a/src/external/bot-skeleton/services/api/api-base.ts b/src/external/bot-skeleton/services/api/api-base.ts
index 73ac5e70..b012ed0d 100644
--- a/src/external/bot-skeleton/services/api/api-base.ts
+++ b/src/external/bot-skeleton/services/api/api-base.ts
@@ -2,6 +2,7 @@ import Cookies from 'js-cookie';
 import CommonStore from '@/stores/common-store';
 import { TAuthData } from '@/types/api-types';
 import { clearAuthData } from '@/utils/auth-utils';
+import { handleBackendError, isBackendError } from '@/utils/error-handler';
 import { setSessionToken } from '@/utils/session-token-utils';
 import { clearInvalidTokenParams } from '@/utils/url-utils';
 import { tradingTimesService } from '../../../../components/shared/services/trading-times-service';
@@ -111,10 +112,15 @@ class APIBase {
                 const response = await this.getSessionToken(oneTimeToken);
 
                 if (response?.error) {
-                    console.error('Token exchange failed:', response.error);
+                    const errorMessage = isBackendError(response.error)
+                        ? handleBackendError(response.error)
+                        : response.error.message || 'Token exchange failed';
+                    console.error('Token exchange failed:', errorMessage);
                     // Clear URL query parameters and emit InvalidToken event for invalid URL parameter tokens
                     clearInvalidTokenParams();
-                    globalObserver.emit('InvalidToken', { error: response.error });
+                    globalObserver.emit('InvalidToken', {
+                        error: { ...response.error, localizedMessage: errorMessage },
+                    });
                     setIsAuthorizing(false);
                     return;
                 }
@@ -227,20 +233,24 @@ class APIBase {
         try {
             const { authorize, error } = await this.api.authorize(this.token);
             if (error) {
+                const errorMessage = isBackendError(error)
+                    ? handleBackendError(error)
+                    : error.message || 'Authorization failed';
+
                 if (error.code === 'InvalidToken') {
                     // Clear URL query parameters for InvalidToken errors
                     clearInvalidTokenParams();
                     if (Cookies.get('logged_state') === 'true') {
-                        globalObserver.emit('InvalidToken', { error });
+                        globalObserver.emit('InvalidToken', { error: { ...error, localizedMessage: errorMessage } });
                     } else {
                         clearAuthData();
                     }
                 } else {
                     // Authorization error
-                    console.error('Authorization error:', error);
+                    console.error('Authorization error:', errorMessage);
                 }
                 setIsAuthorizing(false);
-                return error;
+                return { ...error, localizedMessage: errorMessage };
             }
 
             this.account_info = authorize;
diff --git a/src/external/bot-skeleton/services/tradeEngine/trade/Proposal.js b/src/external/bot-skeleton/services/tradeEngine/trade/Proposal.js
index 139cc60f..1c4f806b 100644
--- a/src/external/bot-skeleton/services/tradeEngine/trade/Proposal.js
+++ b/src/external/bot-skeleton/services/tradeEngine/trade/Proposal.js
@@ -1,4 +1,4 @@
-import { localize } from '@deriv-com/translations';
+import { getLocalizedErrorMessage } from '@/constants/backend-error-messages';
 import { api_base } from '../../api/api-base';
 import { doUntilDone, tradeOptionToProposal } from '../utils/helpers';
 import { clearProposals, proposalsReady } from './state/actions';
@@ -22,7 +22,7 @@ export default Engine =>
             const { proposals } = this.data;
 
             if (proposals.length === 0) {
-                throw Error(localize('Proposals are not ready'));
+                throw Error(getLocalizedErrorMessage('ProposalsNotReady'));
             }
 
             const to_buy = proposals.find(proposal => {
@@ -45,7 +45,7 @@ export default Engine =>
             });
 
             if (!to_buy) {
-                throw new Error(localize('Selected proposal does not exist'));
+                throw new Error(getLocalizedErrorMessage('SelectedProposalNotExist'));
             }
 
             return {
diff --git a/src/external/bot-skeleton/services/tradeEngine/trade/Purchase.js b/src/external/bot-skeleton/services/tradeEngine/trade/Purchase.js
index 092dc3ee..d330b6f3 100644
--- a/src/external/bot-skeleton/services/tradeEngine/trade/Purchase.js
+++ b/src/external/bot-skeleton/services/tradeEngine/trade/Purchase.js
@@ -34,7 +34,7 @@ export default Engine =>
                 }
 
                 delayIndex = 0;
-                log(LogTypes.PURCHASE, { longcode: buy.longcode, transaction_id: buy.transaction_id });
+                log(LogTypes.PURCHASE, { transaction_id: buy.transaction_id });
                 info({
                     accountID: this.accountInfo.loginid,
                     totalRuns: this.updateAndReturnTotalRuns(),
diff --git a/src/external/bot-skeleton/services/tradeEngine/trade/Sell.js b/src/external/bot-skeleton/services/tradeEngine/trade/Sell.js
index e72dfeeb..4aca4ae8 100644
--- a/src/external/bot-skeleton/services/tradeEngine/trade/Sell.js
+++ b/src/external/bot-skeleton/services/tradeEngine/trade/Sell.js
@@ -1,3 +1,4 @@
+import { getLocalizedErrorMessage } from '@/constants/backend-error-messages';
 import { LogTypes } from '../../../constants/messages';
 import { observer as globalObserver } from '../../../utils/observer';
 import { api_base } from '../../api/api-base';
@@ -60,7 +61,7 @@ export default Engine =>
 
                             const sell_error = {
                                 name: error.code,
-                                message: error.message,
+                                message: getLocalizedErrorMessage(error.code, error.details),
                                 msg_type: e.msg_type,
                                 error: { ...error.error },
                             };
diff --git a/src/external/bot-skeleton/services/tradeEngine/trade/Ticks.js b/src/external/bot-skeleton/services/tradeEngine/trade/Ticks.js
index 4a0c8613..8fa717cd 100644
--- a/src/external/bot-skeleton/services/tradeEngine/trade/Ticks.js
+++ b/src/external/bot-skeleton/services/tradeEngine/trade/Ticks.js
@@ -1,5 +1,6 @@
 /* eslint-disable no-promise-executor-return */
 import debounce from 'lodash.debounce';
+import { getLocalizedErrorMessage } from '@/constants/backend-error-messages';
 import { localize } from '@deriv-com/translations';
 import { getLast } from '../../../utils/binary-utils';
 import { observer as globalObserver } from '../../../utils/observer';
@@ -67,7 +68,11 @@ export default Engine =>
                     })
                     .catch(e => {
                         if (e.code === 'MarketIsClosed') {
-                            globalObserver.emit('Error', e);
+                            const localizedError = {
+                                ...e,
+                                message: getLocalizedErrorMessage(e.code, e.details),
+                            };
+                            globalObserver.emit('Error', localizedError);
                             resolve(e.code);
                         }
                     })
diff --git a/src/external/bot-skeleton/services/tradeEngine/trade/Total.js b/src/external/bot-skeleton/services/tradeEngine/trade/Total.js
index a0634ad6..8c82ee86 100644
--- a/src/external/bot-skeleton/services/tradeEngine/trade/Total.js
+++ b/src/external/bot-skeleton/services/tradeEngine/trade/Total.js
@@ -1,5 +1,5 @@
 import { getRoundedNumber } from '@/components/shared';
-import { localize } from '@deriv-com/translations';
+import { getLocalizedErrorMessage } from '@/constants/backend-error-messages';
 import { LogTypes } from '../../../constants/messages';
 import { createError } from '../../../utils/error';
 import { observer as globalObserver } from '../../../utils/observer';
@@ -102,10 +102,10 @@ export default Engine =>
 
             if (maxLoss && maxTrades) {
                 if (this.sessionRuns >= maxTrades) {
-                    throw createError('CustomLimitsReached', localize('Maximum number of trades reached'));
+                    throw createError('CustomLimitsReached', getLocalizedErrorMessage('MaxTradesReached'));
                 }
                 if (this.sessionProfit <= -maxLoss) {
-                    throw createError('CustomLimitsReached', localize('Maximum loss amount reached'));
+                    throw createError('CustomLimitsReached', getLocalizedErrorMessage('MaxLossReached'));
                 }
             }
         }
diff --git a/src/external/bot-skeleton/services/tradeEngine/trade/index.js b/src/external/bot-skeleton/services/tradeEngine/trade/index.js
index f13ad737..1293b427 100644
--- a/src/external/bot-skeleton/services/tradeEngine/trade/index.js
+++ b/src/external/bot-skeleton/services/tradeEngine/trade/index.js
@@ -1,6 +1,6 @@
 import { applyMiddleware, createStore } from 'redux';
 import { thunk } from 'redux-thunk';
-import { localize } from '@deriv-com/translations';
+import { getLocalizedErrorMessage } from '@/constants/backend-error-messages';
 import { createError } from '../../../utils/error';
 import { observer as globalObserver } from '../../../utils/observer';
 import { api_base } from '../../api/api-base';
@@ -90,7 +90,7 @@ export default class TradeEngine extends Balance(Purchase(Sell(OpenContract(Prop
 
     start(tradeOptions) {
         if (!this.options) {
-            throw createError('NotInitialized', localize('Bot.init is not called'));
+            throw createError('NotInitialized', getLocalizedErrorMessage('NotInitialized'));
         }
 
         globalObserver.emit('bot.running');
diff --git a/src/external/bot-skeleton/services/tradeEngine/utils/helpers.js b/src/external/bot-skeleton/services/tradeEngine/utils/helpers.js
index 24d729d9..630a8295 100644
--- a/src/external/bot-skeleton/services/tradeEngine/utils/helpers.js
+++ b/src/external/bot-skeleton/services/tradeEngine/utils/helpers.js
@@ -1,4 +1,5 @@
 import { findValueByKeyRecursively, formatTime, getRoundedNumber, isEmptyObject } from '@/components/shared';
+import { getLocalizedErrorMessage } from '@/constants/backend-error-messages';
 import { config } from '@/external/bot-skeleton/constants';
 import { localize } from '@deriv-com/translations';
 import { observer as globalObserver } from '../../../utils/observer';
@@ -147,47 +148,36 @@ const getBackoffDelayInMs = (error_obj, delay_index) => {
     const { TRADE_TYPE_CATEGORY_NAMES } = config();
 
     if (code) {
+        const error_details = {
+            message_type: error.msg_type,
+            delay: next_delay_in_seconds,
+            request: echo_req?.req_id,
+            message: message || localize('The market is closed'),
+            trade_type: TRADE_TYPE_CATEGORY_NAMES?.[selected_trade_type] ?? '',
+        };
+
         switch (code) {
             case 'RateLimit':
-                message_to_print = localize(
-                    'You are rate limited for: {{ message_type }}, retrying in {{ delay }}s (ID: {{ request }})',
-                    {
-                        message_type: error.msg_type,
-                        delay: next_delay_in_seconds,
-                        request: echo_req?.req_id,
-                    }
-                );
-
+                message_to_print = getLocalizedErrorMessage('RateLimit', error_details);
                 break;
             case 'DisconnectError':
-                message_to_print = localize('You are disconnected, retrying in {{ delay }}s', {
-                    delay: next_delay_in_seconds,
-                });
+                message_to_print = getLocalizedErrorMessage('DisconnectError', error_details);
                 break;
             case 'MarketIsClosed':
-                message_to_print = localize('{{ message }}, retrying in {{ delay }}s', {
-                    message: message || localize('The market is closed'),
-                    delay: next_delay_in_seconds,
-                });
+                message_to_print = getLocalizedErrorMessage('MarketIsClosed', error_details);
                 break;
             case 'OpenPositionLimitExceeded':
-                message_to_print = localize(
-                    'You already have an open position for {{ trade_type }} contract type, retrying in {{ delay }}s',
-                    {
-                        delay: next_delay_in_seconds,
-                        trade_type: TRADE_TYPE_CATEGORY_NAMES?.[selected_trade_type] ?? '',
-                    }
-                );
+                message_to_print = getLocalizedErrorMessage('OpenPositionLimitExceeded', error_details);
                 break;
             default:
-                message_to_print = localize('Request failed for: {{ message_type }}, retrying in {{ delay }}s', {
+                message_to_print = getLocalizedErrorMessage('RequestFailed', {
                     message_type: msg_type || localize('unknown'),
                     delay: next_delay_in_seconds,
                 });
                 break;
         }
     } else {
-        message_to_print = localize('Request failed for: {{ message_type }}, retrying in {{ delay }}s', {
+        message_to_print = getLocalizedErrorMessage('RequestFailed', {
             message_type: msg_type || localize('unknown'),
             delay: next_delay_in_seconds,
         });
@@ -201,10 +191,10 @@ const getBackoffDelayInMs = (error_obj, delay_index) => {
 export const updateErrorMessage = error => {
     if (error.error?.code === 'InputValidationFailed') {
         if (error.error.details?.duration) {
-            error.error.message = localize('Duration must be a positive integer');
+            error.error.message = getLocalizedErrorMessage('DurationValidationFailed');
         }
         if (error.error.details?.amount) {
-            error.error.message = localize('Amount must be a positive number.');
+            error.error.message = getLocalizedErrorMessage('AmountValidationFailed');
         }
     }
 };
diff --git a/src/stores/run-panel-store.ts b/src/stores/run-panel-store.ts
index 58c09038..6d18ff36 100644
--- a/src/stores/run-panel-store.ts
+++ b/src/stores/run-panel-store.ts
@@ -7,6 +7,7 @@ import { contract_stages, TContractStage } from '@/constants/contract-stage';
 import { run_panel } from '@/constants/run-panel';
 import { ErrorTypes, MessageTypes, observer, unrecoverable_errors } from '@/external/bot-skeleton';
 import { getSelectedTradeType } from '@/external/bot-skeleton/scratch/utils';
+import { handleBackendError, isBackendError } from '@/utils/error-handler';
 // import { journalError, switch_account_notification } from '@/utils/bot-notifications';
 import GTM from '@/utils/gtm';
 import { helpers } from '@/utils/store-helpers';
@@ -635,7 +636,12 @@ export default class RunPanelStore {
             this.error_type = ErrorTypes.RECOVERABLE_ERRORS;
         }
 
-        const error_message = error?.message;
+        // Use localized error message if it's a backend error, otherwise fallback to original message
+        let error_message = error?.message;
+        if (isBackendError(error)) {
+            error_message = handleBackendError(error);
+        }
+
         this.showErrorMessage(error_message);
     };
 
diff --git a/src/utils/__tests__/error-handler.spec.ts b/src/utils/__tests__/error-handler.spec.ts
new file mode 100644
index 00000000..24fe741b
--- /dev/null
+++ b/src/utils/__tests__/error-handler.spec.ts
@@ -0,0 +1,80 @@
+import { handleBackendError, isBackendError } from '../error-handler';
+
+// Mock the backend error messages
+jest.mock('../../constants/backend-error-messages', () => ({
+    getLocalizedErrorMessage: jest.fn((errorCode, details) => {
+        if (errorCode === 'InsufficientBalance') {
+            return 'Your account balance is insufficient to buy this contract.';
+        }
+        if (errorCode === 'RateLimit' && details) {
+            return `You are rate limited for: ${details.message_type}, retrying in ${details.delay}s`;
+        }
+        return 'An error occurred. Please try again.';
+    }),
+}));
+
+describe('Error Handler', () => {
+    describe('isBackendError', () => {
+        it('should identify backend errors correctly', () => {
+            const backendError = {
+                code: 'InsufficientBalance',
+                message: 'Insufficient balance',
+            };
+            expect(isBackendError(backendError)).toBe(true);
+        });
+
+        it('should identify non-backend errors correctly', () => {
+            const genericError = new Error('Generic error');
+            expect(isBackendError(genericError)).toBe(false);
+        });
+
+        it('should handle errors with just code property', () => {
+            const errorWithCode = { code: 'RateLimit' };
+            expect(isBackendError(errorWithCode)).toBe(true);
+        });
+
+        it('should reject objects without code property', () => {
+            const invalidError = { message: 'Some error' };
+            expect(isBackendError(invalidError)).toBe(false);
+        });
+    });
+
+    describe('handleBackendError', () => {
+        it('should handle backend errors with InsufficientBalance code', () => {
+            const backendError = {
+                code: 'InsufficientBalance',
+                message: 'Insufficient balance',
+            };
+            const result = handleBackendError(backendError);
+            expect(result).toBe('Your account balance is insufficient to buy this contract.');
+        });
+
+        it('should handle backend errors with RateLimit code and details', () => {
+            const backendError = {
+                code: 'RateLimit',
+                details: {
+                    message_type: 'buy',
+                    delay: '5',
+                },
+            };
+            const result = handleBackendError(backendError);
+            expect(result).toBe('You are rate limited for: buy, retrying in 5s');
+        });
+
+        it('should return fallback message for unknown error codes', () => {
+            const unknownError = {
+                code: 'UnknownErrorCode123',
+            };
+            const result = handleBackendError(unknownError);
+            expect(result).toBe('An error occurred. Please try again.');
+        });
+
+        it('should handle errors without code property', () => {
+            const invalidError = {
+                message: 'Generic error message',
+            } as any;
+            const result = handleBackendError(invalidError);
+            expect(result).toBe('An error occurred. Please try again.');
+        });
+    });
+});
diff --git a/src/utils/error-handler.ts b/src/utils/error-handler.ts
new file mode 100644
index 00000000..44787137
--- /dev/null
+++ b/src/utils/error-handler.ts
@@ -0,0 +1,125 @@
+import { getLocalizedErrorMessage } from '@/constants/backend-error-messages';
+
+/**
+ * Interface for backend error response
+ */
+export interface BackendError {
+    code: string;
+    message?: string;
+    details?: Record<string, any>;
+}
+
+/**
+ * Interface for API error response
+ */
+export interface ApiErrorResponse {
+    error?: BackendError;
+    msg_type?: string;
+}
+
+/**
+ * Handles backend errors and returns localized error messages
+ * @param error - The error object from backend
+ * @returns Localized error message
+ */
+export const handleBackendError = (error: BackendError): string => {
+    if (!error?.code) {
+        return getLocalizedErrorMessage('GeneralError');
+    }
+
+    // Get localized message for the specific error code with details
+    return getLocalizedErrorMessage(error.code, error.details);
+};
+
+/**
+ * Handles API response errors
+ * @param response - The API response object
+ * @returns Localized error message or null if no error
+ */
+export const handleApiError = (response: ApiErrorResponse): string | null => {
+    if (!response?.error) {
+        return null;
+    }
+
+    return handleBackendError(response.error);
+};
+
+/**
+ * Creates a standardized error object for display
+ * @param error - The backend error
+ * @returns Standardized error object
+ */
+export const createErrorObject = (error: BackendError) => ({
+    code: error.code,
+    message: handleBackendError(error),
+    details: error.details,
+});
+
+/**
+ * Utility function to check if an error code requires specific handling
+ * @param errorCode - The error code to check
+ * @returns Boolean indicating if special handling is needed
+ */
+export const requiresSpecialHandling = (errorCode: string): boolean => {
+    const specialHandlingCodes = [
+        'AuthorizationRequired',
+        'InsufficientBalance',
+        'MarketIsClosed',
+        'AccountBalanceExceedsLimit',
+        'DailyProfitLimitExceeded',
+        'ClientUnwelcome',
+    ];
+
+    return specialHandlingCodes.includes(errorCode);
+};
+
+/**
+ * Gets error severity level for UI styling
+ * @param errorCode - The error code
+ * @returns Severity level: 'critical', 'warning', or 'info'
+ */
+export const getErrorSeverity = (errorCode: string): 'critical' | 'warning' | 'info' => {
+    const criticalErrors = [
+        'InternalServerError',
+        'GeneralError',
+        'AuthorizationRequired',
+        'ClientUnwelcome',
+        'TradingDisabled',
+    ];
+
+    const warningErrors = [
+        'InsufficientBalance',
+        'StakeLimitExceeded',
+        'MarketIsClosed',
+        'DailyProfitLimitExceeded',
+        'AccountBalanceExceedsLimit',
+    ];
+
+    if (criticalErrors.includes(errorCode)) {
+        return 'critical';
+    }
+
+    if (warningErrors.includes(errorCode)) {
+        return 'warning';
+    }
+
+    return 'info';
+};
+
+/**
+ * Type guard to check if an object is a backend error
+ * @param obj - Object to check
+ * @returns Boolean indicating if object is a backend error
+ */
+export const isBackendError = (obj: any): obj is BackendError => {
+    return obj && typeof obj === 'object' && typeof obj.code === 'string';
+};
+
+/**
+ * Type guard to check if an object is an API error response
+ * @param obj - Object to check
+ * @returns Boolean indicating if object is an API error response
+ */
+export const isApiErrorResponse = (obj: any): obj is ApiErrorResponse => {
+    return obj && typeof obj === 'object' && obj.error && isBackendError(obj.error);
+};

From afa4e24fac00ad9311fe8e58713722f0860d203e Mon Sep 17 00:00:00 2001
From: Rupato Braganza <rupato@deriv.com>
Date: Fri, 24 Oct 2025 15:17:48 +0800
Subject: [PATCH 7/9] fix: bug fixes for the translations

---
 .../layout/header/account-switcher.tsx        |  4 +--
 .../layout/header/wallets/wallet-badge.tsx    |  3 +-
 .../shared_ui/autocomplete/autocomplete.scss  |  4 +--
 src/components/shared_ui/input/input.scss     | 10 +++---
 .../select-native/select-native.scss          |  4 +--
 src/hooks/api/account/useActiveAccount.tsx    |  3 +-
 .../quick-strategy/quick-strategy.scss        | 33 ++++++++++---------
 src/pages/dashboard/cards.tsx                 |  2 +-
 src/pages/main/main.scss                      |  5 +--
 .../tutorials/dbot-tours/tour-content.tsx     | 17 ++++------
 src/pages/tutorials/tutorials.scss            |  7 ++--
 11 files changed, 42 insertions(+), 50 deletions(-)

diff --git a/src/components/layout/header/account-switcher.tsx b/src/components/layout/header/account-switcher.tsx
index 9fa75da9..1bdcd478 100644
--- a/src/components/layout/header/account-switcher.tsx
+++ b/src/components/layout/header/account-switcher.tsx
@@ -3,7 +3,7 @@ import classNames from 'classnames';
 import { observer } from 'mobx-react-lite';
 import { getCurrencyDisplayCode } from '@/components/shared';
 import Text from '@/components/shared_ui/text';
-import { Localize, localize } from '@deriv-com/translations';
+import { Localize } from '@deriv-com/translations';
 import { useDevice } from '@deriv-com/ui';
 import { TAccountSwitcher } from './common/types';
 import AccountInfoIcon from './account-info-icon';
@@ -43,7 +43,7 @@ const AccountSwitcher = observer(({ activeAccount }: TAccountSwitcher) => {
                     <div className='acc-info__content'>
                         <div className='acc-info__account-type-header'>
                             <Text as='p' size='xxxs' className='acc-info__account-type'>
-                                {isVirtual ? localize('Demo') : localize('Real')}
+                                {isVirtual ? 'Demo' : 'Real'}
                             </Text>
                         </div>
                         {(typeof balance !== 'undefined' || !currency) && (
diff --git a/src/components/layout/header/wallets/wallet-badge.tsx b/src/components/layout/header/wallets/wallet-badge.tsx
index e3a95629..9165d842 100644
--- a/src/components/layout/header/wallets/wallet-badge.tsx
+++ b/src/components/layout/header/wallets/wallet-badge.tsx
@@ -1,6 +1,5 @@
 import React from 'react';
 import Badge from '@/components/shared_ui/badge';
-import { localize } from '@deriv-com/translations';
 
 type TWalletBadge = {
     is_demo: boolean;
@@ -9,7 +8,7 @@ type TWalletBadge = {
 
 const WalletBadge = ({ is_demo, label }: TWalletBadge) => {
     return is_demo ? (
-        <Badge type='contained' background_color='blue' label={localize('Demo')} custom_color='colored-background' />
+        <Badge type='contained' background_color='blue' label='Demo' custom_color='colored-background' />
     ) : (
         <Badge type='bordered' label={label?.toUpperCase() ?? ''} />
     );
diff --git a/src/components/shared_ui/autocomplete/autocomplete.scss b/src/components/shared_ui/autocomplete/autocomplete.scss
index f4ff5ffd..b59c1fc4 100644
--- a/src/components/shared_ui/autocomplete/autocomplete.scss
+++ b/src/components/shared_ui/autocomplete/autocomplete.scss
@@ -6,9 +6,9 @@
 
     &__trailing-icon {
         position: absolute;
-        right: 0;
+        inset-inline-end: 0;
         pointer-events: none;
-        margin-right: 1.1rem;
+        margin-inline-end: 1.1rem;
         cursor: text;
         transition: transform 0.2s ease;
         transform: rotate(0deg);
diff --git a/src/components/shared_ui/input/input.scss b/src/components/shared_ui/input/input.scss
index 446d545d..80364a27 100644
--- a/src/components/shared_ui/input/input.scss
+++ b/src/components/shared_ui/input/input.scss
@@ -216,10 +216,10 @@
     }
 
     &__leading-icon {
-        margin-left: 1rem;
+        margin-inline-start: 1rem;
         top: 1rem;
         position: absolute;
-        left: 0;
+        inset-inline-start: 0;
         pointer-events: none;
         cursor: text;
         font-size: var(--text-size-xs);
@@ -229,18 +229,18 @@
 
             + .dc-input__field {
                 // default padding for three letter currency symbols
-                padding-left: calc(1.6rem + 2.4rem);
+                padding-inline-start: calc(1.6rem + 2.4rem);
             }
 
             &--usdc + .dc-input__field,
             &--ust + .dc-input__field {
-                padding-left: calc(1.6rem + 3.2rem);
+                padding-inline-start: calc(1.6rem + 3.2rem);
             }
         }
     }
 
     &__trailing-icon {
-        right: 0;
+        // right: 0;
         font-size: var(--text-size-xs);
 
         &.symbols {
diff --git a/src/components/shared_ui/select-native/select-native.scss b/src/components/shared_ui/select-native/select-native.scss
index 40ced514..334b8adb 100644
--- a/src/components/shared_ui/select-native/select-native.scss
+++ b/src/components/shared_ui/select-native/select-native.scss
@@ -49,8 +49,6 @@
     }
 
     &__arrow {
-        position: absolute;
-        right: 1.3rem;
         fill: var(--text-general);
 
         --fill-color1: var(--text-less-prominent);
@@ -63,7 +61,7 @@
         display: flex;
         align-items: center;
         justify-content: flex-start;
-        padding-left: 1.2rem;
+        padding-inline-start: 1.2rem;
 
         &-text {
             color: var(--text-prominent);
diff --git a/src/hooks/api/account/useActiveAccount.tsx b/src/hooks/api/account/useActiveAccount.tsx
index 117d1aa1..9a817580 100644
--- a/src/hooks/api/account/useActiveAccount.tsx
+++ b/src/hooks/api/account/useActiveAccount.tsx
@@ -3,7 +3,6 @@ import { CurrencyIcon } from '@/components/currency/currency-icon';
 import { addComma, getDecimalPlaces } from '@/components/shared';
 import { useApiBase } from '@/hooks/useApiBase';
 import { Balance } from '@deriv/api-types';
-import { localize } from '@deriv-com/translations';
 
 /** A custom hook that returns the account object for the current active account. */
 const useActiveAccount = ({
@@ -37,7 +36,7 @@ const useActiveAccount = ({
                 : directBalance
                   ? addComma(parseFloat(directBalance).toFixed(getDecimalPlaces(activeAccount.currency)))
                   : addComma(parseFloat('0').toFixed(getDecimalPlaces(activeAccount.currency))),
-            currencyLabel: isVirtual ? localize('Demo') : activeAccount?.currency,
+            currencyLabel: isVirtual ? 'Demo' : activeAccount?.currency,
             icon: <CurrencyIcon currency={activeAccount?.currency?.toLowerCase()} isVirtual={isVirtual} />,
             isVirtual: isVirtual,
             isActive: activeAccount?.loginid === activeLoginid,
diff --git a/src/pages/bot-builder/quick-strategy/quick-strategy.scss b/src/pages/bot-builder/quick-strategy/quick-strategy.scss
index 5fedfc7b..dc378848 100644
--- a/src/pages/bot-builder/quick-strategy/quick-strategy.scss
+++ b/src/pages/bot-builder/quick-strategy/quick-strategy.scss
@@ -385,13 +385,13 @@
                 margin: 0;
                 padding: 0;
                 top: -3.4rem;
-                right: 6rem;
+                inset-inline-end: 6rem;
                 display: flex;
                 flex-direction: row-reverse;
 
                 @include mobile-or-tablet-screen {
                     top: -2.6rem;
-                    right: 5rem;
+                    inset-inline-end: 5rem;
                 }
 
                 .dc-text {
@@ -414,13 +414,13 @@
 
             &__leading-icon {
                 top: 1.4rem;
-                left: 1.4rem;
+                inset-inline-start: 1.4rem;
                 height: 2.4rem;
                 width: 2.4rem;
 
                 @include mobile-or-tablet-screen {
                     top: 50%;
-                    left: 0;
+                    inset-inline-start: 0;
                     transform: translateY(-50%);
                 }
 
@@ -434,18 +434,19 @@
             }
 
             &__field {
-                margin-inline-start: 6rem;
+                margin-inline-start: 4rem;
+                margin-inline-end: 4rem;
                 font-weight: bold;
                 color: var(--text-general);
             }
 
             &__field[name='symbol'] {
                 caret-color: auto;
-                margin-inline-start: 2.4rem;
+                margin-inline-end: 2.4rem;
             }
 
             &__trailing-icon {
-                margin-right: 2.4rem;
+                margin-inline-end: 2.4rem;
             }
         }
     }
@@ -462,6 +463,8 @@
             }
 
             &__field {
+                margin-inline-start: 4rem;
+                margin-inline-end: 4rem;
                 font-weight: bold;
                 color: var(--text-general);
 
@@ -472,19 +475,19 @@
 
             &__leading-icon {
                 top: 1.6rem;
-                left: 1.6rem;
+                inset-inline-start: 1.6rem;
 
                 .dc-icon {
-                    margin-right: 0.6rem;
+                    margin-inline-end: 1.2rem;
 
                     &:last-child {
-                        margin-right: 0;
+                        margin-inline-end: 0;
                     }
                 }
             }
 
             &__trailing-icon {
-                margin-right: 2.4rem;
+                margin-inline-end: 1.6rem;
             }
         }
 
@@ -554,11 +557,11 @@
             &__leading-icon {
                 @extend .seddle-actions;
 
-                left: 0.3rem;
+                inset-inline-start: 0.3rem;
                 color: var(--text-general);
 
                 @include mobile-or-tablet-screen {
-                    left: 0.2rem;
+                    inset-inline-start: 0.2rem;
                 }
 
                 &:hover {
@@ -574,11 +577,11 @@
             &__trailing-icon {
                 @extend .seddle-actions;
 
-                right: 1rem;
+                inset-inline-end: 1rem;
                 color: var(--text-general);
 
                 @include mobile-or-tablet-screen {
-                    right: 1.6rem;
+                    inset-inline-end: 1.6rem;
                 }
 
                 &:hover {
diff --git a/src/pages/dashboard/cards.tsx b/src/pages/dashboard/cards.tsx
index 4cced097..fe8621a6 100644
--- a/src/pages/dashboard/cards.tsx
+++ b/src/pages/dashboard/cards.tsx
@@ -89,7 +89,7 @@ const Cards = observer(({ is_mobile, has_dashboard_strategies }: TCardProps) =>
         {
             id: 'bot-builder',
             icon: <DerivLightBotBuilderIcon height='48px' width='48px' />,
-            content: <Localize i18n_default_text='Bot builder' />,
+            content: <Localize i18n_default_text='Bot Builder' />,
             callback: () => {
                 setActiveTab(DBOT_TABS.BOT_BUILDER);
                 rudderStackSendDashboardClickEvent({
diff --git a/src/pages/main/main.scss b/src/pages/main/main.scss
index 0401cec8..87895536 100644
--- a/src/pages/main/main.scss
+++ b/src/pages/main/main.scss
@@ -604,7 +604,6 @@
     &__content {
         text-align: center;
         padding: 0 1.6rem;
-        margin-bottom: 1.6rem;
 
         @include mobile-or-tablet-screen {
             line-height: 1.8;
@@ -621,7 +620,7 @@
         text-align: center;
         width: 100%;
         height: 55%;
-        margin-bottom: 1.6rem;
+        margin-bottom: auto;
     }
 
     img {
@@ -639,8 +638,6 @@
 
     &__status {
         width: 100%;
-        position: fixed;
-        bottom: 1.6rem;
     }
 
     &__button-group {
diff --git a/src/pages/tutorials/dbot-tours/tour-content.tsx b/src/pages/tutorials/dbot-tours/tour-content.tsx
index e2a5314d..20992fb3 100644
--- a/src/pages/tutorials/dbot-tours/tour-content.tsx
+++ b/src/pages/tutorials/dbot-tours/tour-content.tsx
@@ -391,42 +391,37 @@ export const BOT_BUILDER_TOUR = [
     {
         target: '.animation__wrapper',
         content: <Step1 show_label />,
-        placement: isDbotRTL() ? 'bottom' : 'right',
+        placement: isDbotRTL() ? 'left' : 'right',
         ...joyride_props,
     },
     {
         target: '.animation__wrapper',
         content: <Step1A />,
-        placement: isDbotRTL() ? 'bottom' : 'right',
-
+        placement: isDbotRTL() ? 'left' : 'right',
         ...joyride_props,
     },
     {
         target: '.animation__wrapper',
         content: <Step2 show_label />,
-        placement: isDbotRTL() ? 'bottom' : 'right',
-
+        placement: isDbotRTL() ? 'left' : 'right',
         ...joyride_props,
     },
     {
         target: '.animation__wrapper',
         content: <Step3 show_label />,
-        placement: isDbotRTL() ? 'bottom' : 'right',
-
+        placement: isDbotRTL() ? 'left' : 'right',
         ...joyride_props,
     },
     {
         target: '.animation__wrapper',
         content: <Step4 show_label />,
-        placement: isDbotRTL() ? 'bottom' : 'right',
-
+        placement: isDbotRTL() ? 'left' : 'right',
         ...joyride_props,
     },
     {
         target: '.animation__wrapper',
         content: <Step5 show_label />,
-        placement: isDbotRTL() ? 'bottom' : 'right',
-
+        placement: isDbotRTL() ? 'left' : 'right',
         ...joyride_props,
     },
     {
diff --git a/src/pages/tutorials/tutorials.scss b/src/pages/tutorials/tutorials.scss
index 524b3962..60812f6d 100644
--- a/src/pages/tutorials/tutorials.scss
+++ b/src/pages/tutorials/tutorials.scss
@@ -126,13 +126,14 @@
         @include mobile-or-tablet-screen {
             height: 8.7rem;
             width: 14.8rem;
-            margin: 0 0.8rem 0.8rem 0;
+            margin-inline-end: 0.8rem;
         }
 
         &__tours {
             height: 13.5rem;
             background-size: contain;
-            margin: 0 0.8rem 0.8rem 0;
+            margin-bottom: 0.8rem;
+            margin-inline-end: 0.8rem;
             width: 21.5rem;
             cursor: pointer;
 
@@ -267,7 +268,7 @@
                     outline: none;
                     background-color: var(--general-main-1);
                     font-size: 1.4rem;
-                    padding: 0 3.6rem;
+                    padding-inline: 3.6rem;
                     border: solid 1px var(--border-normal);
                     color: var(--text-general);
 

From c25b72487bfce0adb0ebc08ee30937895045aced Mon Sep 17 00:00:00 2001
From: Rupato Braganza <rupato@deriv.com>
Date: Fri, 24 Oct 2025 15:39:21 +0800
Subject: [PATCH 8/9] fix: bug fixes for the translations

---
 src/external/bot-skeleton/constants/config.ts | 148 +++++++++---------
 src/pages/tutorials/tutorials.scss            |   2 +-
 2 files changed, 71 insertions(+), 79 deletions(-)

diff --git a/src/external/bot-skeleton/constants/config.ts b/src/external/bot-skeleton/constants/config.ts
index c83117b0..5f4e5ab4 100644
--- a/src/external/bot-skeleton/constants/config.ts
+++ b/src/external/bot-skeleton/constants/config.ts
@@ -1,53 +1,51 @@
-import { localize } from '@deriv-com/translations';
-
 const CRYPTO_CURRENCIES = ['BTC', 'ETH', 'LTC', 'BCH', 'UST'];
 
 export const config = () => ({
     lists: {
         PAYOUTTYPE: [
-            // [localize('Payout'), 'payout'],
-            [localize('Stake'), 'stake'],
+            // ['Payout', 'payout'],
+            ['Stake', 'stake'],
         ],
         CRYPTO_CURRENCIES,
         DETAILS: [
-            [localize('deal reference id'), '1'],
-            [localize('purchase price'), '2'],
-            [localize('payout'), '3'],
-            [localize('profit'), '4'],
-            [localize('contract type'), '5'],
-            [localize('entry spot time'), '6'],
-            [localize('entry spot price'), '7'],
-            [localize('exit spot time'), '8'],
-            [localize('exit spot price'), '9'],
-            [localize('barrier'), '10'],
-            [localize('result'), '11'],
+            ['deal reference id', '1'],
+            ['purchase price', '2'],
+            ['payout', '3'],
+            ['profit', '4'],
+            ['contract type', '5'],
+            ['entry spot time', '6'],
+            ['entry spot price', '7'],
+            ['exit spot time', '8'],
+            ['exit spot price', '9'],
+            ['barrier', '10'],
+            ['result', '11'],
         ],
         CHECK_RESULT: [
-            [localize('Win'), 'win'],
-            [localize('Loss'), 'loss'],
+            ['Win', 'win'],
+            ['Loss', 'loss'],
         ],
         CHECK_DIRECTION: [
-            [localize('Rise'), 'rise'],
-            [localize('Fall'), 'fall'],
-            [localize('No Change'), ''],
+            ['Rise', 'rise'],
+            ['Fall', 'fall'],
+            ['No Change', ''],
         ],
         BALANCE_TYPE: [
-            [localize('string'), 'STR'],
-            [localize('number'), 'NUM'],
+            ['string', 'STR'],
+            ['number', 'NUM'],
         ],
         NOTIFICATION_TYPE: [
-            [localize('green'), 'success'],
-            [localize('blue'), 'info'],
-            [localize('yellow'), 'warn'],
-            [localize('red'), 'error'],
+            ['green', 'success'],
+            ['blue', 'info'],
+            ['yellow', 'warn'],
+            ['red', 'error'],
         ],
         NOTIFICATION_SOUND: [
-            [localize('Silent'), 'silent'],
-            [localize('Announcement'), 'announcement'],
-            [localize('Earned money'), 'earned-money'],
-            [localize('Job done'), 'job-done'],
-            [localize('Error'), 'error'],
-            [localize('Severe error'), 'severe-error'],
+            ['Silent', 'silent'],
+            ['Announcement', 'announcement'],
+            ['Earned money', 'earned-money'],
+            ['Job done', 'job-done'],
+            ['Error', 'error'],
+            ['Severe error', 'severe-error'],
         ],
         CURRENCY: ['USD', 'EUR', 'GBP', 'AUD', ...CRYPTO_CURRENCIES],
     },
@@ -183,26 +181,26 @@ export const config = () => ({
         ['Offset -', '-'],
     ],
     ohlcFields: [
-        [localize('Open'), 'open'],
-        [localize('High'), 'high'],
-        [localize('Low'), 'low'],
-        [localize('Close'), 'close'],
-        [localize('Open Time'), 'epoch'],
+        ['Open', 'open'],
+        ['High', 'high'],
+        ['Low', 'low'],
+        ['Close', 'close'],
+        ['Open Time', 'epoch'],
     ],
     candleIntervals: [
-        [localize('Default'), 'default'],
-        [localize('1 minute'), '60'],
-        [localize('2 minutes'), '120'],
-        [localize('3 minutes'), '180'],
-        [localize('5 minutes'), '300'],
-        [localize('10 minutes'), '600'],
-        [localize('15 minutes'), '900'],
-        [localize('30 minutes'), '1800'],
-        [localize('1 hour'), '3600'],
-        [localize('2 hours'), '7200'],
-        [localize('4 hours'), '14400'],
-        [localize('8 hours'), '28800'],
-        [localize('1 day'), '86400'],
+        ['Default', 'default'],
+        ['1 minute', '60'],
+        ['2 minutes', '120'],
+        ['3 minutes', '180'],
+        ['5 minutes', '300'],
+        ['10 minutes', '600'],
+        ['15 minutes', '900'],
+        ['30 minutes', '1800'],
+        ['1 hour', '3600'],
+        ['2 hours', '7200'],
+        ['4 hours', '14400'],
+        ['8 hours', '28800'],
+        ['1 day', '86400'],
     ],
     mainBlocks: ['trade_definition', 'before_purchase', 'during_purchase', 'after_purchase'],
     mandatoryMainBlocks: ['trade_definition', 'purchase', 'before_purchase'],
@@ -250,29 +248,29 @@ export const config = () => ({
         accumulator: ['accumulator'],
     },
     DEFAULT_DURATION_DROPDOWN_OPTIONS: [
-        [localize('Ticks'), 't'],
-        [localize('Seconds'), 's'],
-        [localize('Minutes'), 'm'],
-        [localize('Hours'), 'h'],
-        [localize('Days'), 'd'],
+        ['Ticks', 't'],
+        ['Seconds', 's'],
+        ['Minutes', 'm'],
+        ['Hours', 'h'],
+        ['Days', 'd'],
     ],
-    BARRIER_LABELS: [localize('High barrier'), localize('Low barrier')],
-    ABSOLUTE_BARRIER_DROPDOWN_OPTION: [[localize('Absolute'), 'absolute']],
-    NOT_AVAILABLE_DROPDOWN_OPTIONS: [[localize('Not available'), 'na']],
-    NOT_AVAILABLE_DURATIONS: [{ display: localize('Not available'), unit: 'na', min: 0 }],
+    BARRIER_LABELS: ['High barrier', 'Low barrier'],
+    ABSOLUTE_BARRIER_DROPDOWN_OPTION: [['Absolute', 'absolute']],
+    NOT_AVAILABLE_DROPDOWN_OPTIONS: [['Not available', 'na']],
+    NOT_AVAILABLE_DURATIONS: [{ display: 'Not available', unit: 'na', min: 0 }],
     BARRIER_TRADE_TYPES: ['higherlower', 'touchnotouch', 'endsinout', 'staysinout', 'callputspread'],
     PREDICTION_TRADE_TYPES: ['matchesdiffers', 'overunder', 'highlowticks'],
     DIGIT_CATEGORIES: ['digits', 'highlowticks'],
     INDEPEDENT_BLOCKS: ['block_holder', 'tick_analysis', 'loader', 'procedures_defreturn', 'procedures_defnoreturn'],
     bbResult: [
-        [localize('upper'), '1'],
-        [localize('middle'), '0'],
-        [localize('lower'), '2'],
+        ['upper', '1'],
+        ['middle', '0'],
+        ['lower', '2'],
     ],
     macdFields: [
-        [localize('Histogram'), '0'],
-        [localize('MACD'), '1'],
-        [localize('Signal'), '2'],
+        ['Histogram', '0'],
+        ['MACD', '1'],
+        ['Signal', '2'],
     ],
     GOOGLE_DRIVE: {
         SCOPE: 'https://www.googleapis.com/auth/drive.file',
@@ -287,27 +285,21 @@ export const config = () => ({
     strategies: {
         martingale: {
             index: 0,
-            label: localize('Martingale'),
-            description: localize(
-                'The Martingale Strategy is a classic trading technique that has been used for more than a hundred years, popularised by the French mathematician Paul Pierre Levy in the 18th century.'
-            ),
+            label: 'Martingale',
+            description: 'The Martingale Strategy is a classic trading technique that has been used for more than a hundred years, popularised by the French mathematician Paul Pierre Levy in the 18th century.',
         },
         dalembert: {
             index: 1,
-            label: localize("D'Alembert"),
-            description: localize(
-                'The concept of the D’Alembert Strategy is said to be similar to the Martingale Strategy where you will increase your contract size after a loss. With the D’Alembert Strategy, you will also decrease your contract size after a successful trade.'
-            ),
+            label: "D'Alembert",
+            description: "The concept of the D'Alembert Strategy is said to be similar to the Martingale Strategy where you will increase your contract size after a loss. With the D'Alembert Strategy, you will also decrease your contract size after a successful trade.",
         },
         oscars_grind: {
             index: 2,
-            label: localize("Oscar's Grind"),
-            description: localize(
-                "The Oscar's Grind Strategy is a low-risk positive progression strategy that first appeared in 1965. By using this strategy, the size of your contract will increase after successful trades, but remains unchanged after unsuccessful trades."
-            ),
+            label: "Oscar's Grind",
+            description: "The Oscar's Grind Strategy is a low-risk positive progression strategy that first appeared in 1965. By using this strategy, the size of your contract will increase after successful trades, but remains unchanged after unsuccessful trades.",
         },
     },
-    default_file_name: localize('Untitled Bot'),
+    default_file_name: 'Untitled Bot',
     DISABLED_SYMBOLS: ['frxGBPNOK', 'frxUSDNOK', 'frxUSDNEK', 'frxUSDSEK'],
     DISABLED_SUBMARKETS: ['energy'],
     QUICK_STRATEGY: {
diff --git a/src/pages/tutorials/tutorials.scss b/src/pages/tutorials/tutorials.scss
index 60812f6d..7fff33ca 100644
--- a/src/pages/tutorials/tutorials.scss
+++ b/src/pages/tutorials/tutorials.scss
@@ -268,7 +268,7 @@
                     outline: none;
                     background-color: var(--general-main-1);
                     font-size: 1.4rem;
-                    padding-inline: 3.6rem;
+                    padding: 0 3.6rem;
                     border: solid 1px var(--border-normal);
                     color: var(--text-general);
 

From bc1bfc854b00f06e64b26637c06bb2cf719fc7bc Mon Sep 17 00:00:00 2001
From: Rupato Braganza <rupato@deriv.com>
Date: Fri, 24 Oct 2025 16:29:39 +0800
Subject: [PATCH 9/9] fix: bug fixes for the translations

---
 .../shared/utils/constants/contract.ts        | 379 +++++++++---------
 src/external/bot-skeleton/constants/config.ts | 139 ++++---
 2 files changed, 262 insertions(+), 256 deletions(-)

diff --git a/src/components/shared/utils/constants/contract.ts b/src/components/shared/utils/constants/contract.ts
index 0190e836..7698201a 100644
--- a/src/components/shared/utils/constants/contract.ts
+++ b/src/components/shared/utils/constants/contract.ts
@@ -1,17 +1,16 @@
 import React from 'react';
-import { localize } from '@deriv-com/translations';
 import { CONTRACT_TYPES, TRADE_TYPES } from '../contract';
 import { TContractOptions } from '../contract/contract-types';
 
 export const getLocalizedBasis = () =>
     ({
-        accumulator: localize('Accumulators'),
-        multiplier: localize('Multiplier'),
-        payout_per_pip: localize('Payout per pip'),
-        payout_per_point: localize('Payout per point'),
-        payout: localize('Payout'),
-        stake: localize('Stake'),
-        turbos: localize('Turbos'),
+        accumulator: 'Accumulators',
+        multiplier: 'Multiplier',
+        payout_per_pip: 'Payout per pip',
+        payout_per_point: 'Payout per point',
+        payout: 'Payout',
+        stake: 'Stake',
+        turbos: 'Turbos',
     }) as const;
 
 type TContractConfig = {
@@ -38,160 +37,158 @@ export type TTradeTypesCategories = {
 
 export const getCardLabels = () =>
     ({
-        APPLY: localize('Apply'),
-        BARRIER: localize('Barrier:'),
-        BUY_PRICE: localize('Buy price:'),
-        CANCEL: localize('Cancel'),
-        CLOSE: localize('Close'),
-        CLOSED: localize('Closed'),
-        CONTRACT_COST: localize('Contract cost:'),
-        CONTRACT_VALUE: localize('Contract value:'),
-        CURRENT_STAKE: localize('Current stake:'),
-        DAY: localize('day'),
-        DAYS: localize('days'),
-        DEAL_CANCEL_FEE: localize('Deal cancel. fee:'),
-        DECREMENT_VALUE: localize('Decrement value'),
-        DONT_SHOW_THIS_AGAIN: localize("Don't show this again"),
-        ENTRY_SPOT: localize('Entry spot:'),
-        INCREMENT_VALUE: localize('Increment value'),
-        INDICATIVE_PRICE: localize('Indicative price:'),
-        INITIAL_STAKE: localize('Initial stake:'),
-        LOST: localize('Lost'),
-        MULTIPLIER: localize('Multiplier:'),
-        NOT_AVAILABLE: localize('N/A'),
-        PAYOUT: localize('Sell price:'),
-        POTENTIAL_PAYOUT: localize('Potential payout:'),
-        POTENTIAL_PROFIT_LOSS: localize('Potential profit/loss:'),
-        PROFIT_LOSS: localize('Profit/Loss:'),
-        PURCHASE_PRICE: localize('Buy price:'),
-        RESALE_NOT_OFFERED: localize('Resale not offered'),
-        SELL: localize('Sell'),
-        STAKE: localize('Stake:'),
-        STOP_LOSS: localize('Stop loss:'),
-        STRIKE: localize('Strike:'),
-        TAKE_PROFIT: localize('Take profit:'),
-        TICK: localize('Tick '),
-        TICKS: localize('Ticks'),
-        TOTAL_PROFIT_LOSS: localize('Total profit/loss:'),
-        TAKE_PROFIT_LOSS_NOT_AVAILABLE: localize(
-            'Take profit and/or stop loss are not available while deal cancellation is active.'
-        ),
-        WON: localize('Won'),
+        APPLY: 'Apply',
+        BARRIER: 'Barrier:',
+        BUY_PRICE: 'Buy price:',
+        CANCEL: 'Cancel',
+        CLOSE: 'Close',
+        CLOSED: 'Closed',
+        CONTRACT_COST: 'Contract cost:',
+        CONTRACT_VALUE: 'Contract value:',
+        CURRENT_STAKE: 'Current stake:',
+        DAY: 'day',
+        DAYS: 'days',
+        DEAL_CANCEL_FEE: 'Deal cancel. fee:',
+        DECREMENT_VALUE: 'Decrement value',
+        DONT_SHOW_THIS_AGAIN: "Don't show this again",
+        ENTRY_SPOT: 'Entry spot:',
+        INCREMENT_VALUE: 'Increment value',
+        INDICATIVE_PRICE: 'Indicative price:',
+        INITIAL_STAKE: 'Initial stake:',
+        LOST: 'Lost',
+        MULTIPLIER: 'Multiplier:',
+        NOT_AVAILABLE: 'N/A',
+        PAYOUT: 'Sell price:',
+        POTENTIAL_PAYOUT: 'Potential payout:',
+        POTENTIAL_PROFIT_LOSS: 'Potential profit/loss:',
+        PROFIT_LOSS: 'Profit/Loss:',
+        PURCHASE_PRICE: 'Buy price:',
+        RESALE_NOT_OFFERED: 'Resale not offered',
+        SELL: 'Sell',
+        STAKE: 'Stake:',
+        STOP_LOSS: 'Stop loss:',
+        STRIKE: 'Strike:',
+        TAKE_PROFIT: 'Take profit:',
+        TICK: 'Tick ',
+        TICKS: 'Ticks',
+        TOTAL_PROFIT_LOSS: 'Total profit/loss:',
+        TAKE_PROFIT_LOSS_NOT_AVAILABLE: 'Take profit and/or stop loss are not available while deal cancellation is active.',
+        WON: 'Won',
     }) as const;
 
 export const getMarketNamesMap = () =>
     ({
-        FRXAUDCAD: localize('AUD/CAD'),
-        FRXAUDCHF: localize('AUD/CHF'),
-        FRXAUDJPY: localize('AUD/JPY'),
-        FRXAUDNZD: localize('AUD/NZD'),
-        FRXAUDPLN: localize('AUD/PLN'),
-        FRXAUDUSD: localize('AUD/USD'),
-        FRXBROUSD: localize('Oil/USD'),
-        FRXEURAUD: localize('EUR/AUD'),
-        FRXEURCAD: localize('EUR/CAD'),
-        FRXEURCHF: localize('EUR/CHF'),
-        FRXEURGBP: localize('EUR/GBP'),
-        FRXEURJPY: localize('EUR/JPY'),
-        FRXEURNZD: localize('EUR/NZD'),
-        FRXEURUSD: localize('EUR/USD'),
-        FRXGBPAUD: localize('GBP/AUD'),
-        FRXGBPCAD: localize('GBP/CAD'),
-        FRXGBPCHF: localize('GBP/CHF'),
-        FRXGBPJPY: localize('GBP/JPY'),
-        FRXGBPNOK: localize('GBP/NOK'),
-        FRXGBPUSD: localize('GBP/USD'),
-        FRXNZDJPY: localize('NZD/JPY'),
-        FRXNZDUSD: localize('NZD/USD'),
-        FRXUSDCAD: localize('USD/CAD'),
-        FRXUSDCHF: localize('USD/CHF'),
-        FRXUSDJPY: localize('USD/JPY'),
-        FRXUSDNOK: localize('USD/NOK'),
-        FRXUSDPLN: localize('USD/PLN'),
-        FRXUSDSEK: localize('USD/SEK'),
-        FRXXAGUSD: localize('Silver/USD'),
-        FRXXAUUSD: localize('Gold/USD'),
-        FRXXPDUSD: localize('Palladium/USD'),
-        FRXXPTUSD: localize('Platinum/USD'),
-        WLDXAU: localize('Gold Basket'),
-        OTC_AEX: localize('Netherlands 25'),
-        OTC_AS51: localize('Australia 200'),
-        OTC_DJI: localize('Wall Street 30'),
-        OTC_FCHI: localize('France 40'),
-        OTC_FTSE: localize('UK 100'),
-        OTC_GDAXI: localize('Germany 40'),
-        OTC_HSI: localize('Hong Kong 50'),
-        OTC_IBEX35: localize('Spain 35'),
-        OTC_N225: localize('Japan 225'),
-        OTC_NDX: localize('US Tech 100'),
-        OTC_SPC: localize('US 500'),
-        OTC_SPX500: localize('US 500'),
-        OTC_SSMI: localize('Swiss 20'),
-        OTC_SX5E: localize('Euro 50'),
-        R_10: localize('Volatility 10 Index'),
-        R_25: localize('Volatility 25 Index'),
-        R_50: localize('Volatility 50 Index'),
-        R_75: localize('Volatility 75 Index'),
-        R_100: localize('Volatility 100 Index'),
-        BOOM300N: localize('Boom 300 Index'),
-        BOOM500: localize('Boom 500 Index'),
-        BOOM1000: localize('Boom 1000 Index'),
-        CRASH300N: localize('Crash 300 Index'),
-        CRASH500: localize('Crash 500 Index'),
-        CRASH1000: localize('Crash 1000 Index'),
-        RDBEAR: localize('Bear Market Index'),
-        RDBULL: localize('Bull Market Index'),
-        STPRNG: localize('Step Index'),
-        WLDAUD: localize('AUD Basket'),
-        WLDEUR: localize('EUR Basket'),
-        WLDGBP: localize('GBP Basket'),
-        WLDUSD: localize('USD Basket'),
-        '1HZ10V': localize('Volatility 10 (1s) Index'),
-        '1HZ15V': localize('Volatility 15 (1s) Index'),
-        '1HZ25V': localize('Volatility 25 (1s) Index'),
-        '1HZ30V': localize('Volatility 30 (1s) Index'),
-        '1HZ50V': localize('Volatility 50 (1s) Index'),
-        '1HZ75V': localize('Volatility 75 (1s) Index'),
-        '1HZ90V': localize('Volatility 90 (1s) Index'),
-        '1HZ100V': localize('Volatility 100 (1s) Index'),
-        '1HZ150V': localize('Volatility 150 (1s) Index'),
-        '1HZ200V': localize('Volatility 200 (1s) Index'),
-        '1HZ250V': localize('Volatility 250 (1s) Index'),
-        '1HZ300V': localize('Volatility 300 (1s) Index'),
-        JD10: localize('Jump 10 Index'),
-        JD25: localize('Jump 25 Index'),
-        JD50: localize('Jump 50 Index'),
-        JD75: localize('Jump 75 Index'),
-        JD100: localize('Jump 100 Index'),
-        JD150: localize('Jump 150 Index'),
-        JD200: localize('Jump 200 Index'),
-        CRYBCHUSD: localize('BCH/USD'),
-        CRYBNBUSD: localize('BNB/USD'),
-        CRYBTCLTC: localize('BTC/LTC'),
-        CRYIOTUSD: localize('IOT/USD'),
-        CRYNEOUSD: localize('NEO/USD'),
-        CRYOMGUSD: localize('OMG/USD'),
-        CRYTRXUSD: localize('TRX/USD'),
-        CRYBTCETH: localize('BTC/ETH'),
-        CRYZECUSD: localize('ZEC/USD'),
-        CRYXMRUSD: localize('ZMR/USD'),
-        CRYXMLUSD: localize('XLM/USD'),
-        CRYXRPUSD: localize('XRP/USD'),
-        CRYBTCUSD: localize('BTC/USD'),
-        CRYDSHUSD: localize('DSH/USD'),
-        CRYETHUSD: localize('ETH/USD'),
-        CRYEOSUSD: localize('EOS/USD'),
-        CRYLTCUSD: localize('LTC/USD'),
+        FRXAUDCAD: 'AUD/CAD',
+        FRXAUDCHF: 'AUD/CHF',
+        FRXAUDJPY: 'AUD/JPY',
+        FRXAUDNZD: 'AUD/NZD',
+        FRXAUDPLN: 'AUD/PLN',
+        FRXAUDUSD: 'AUD/USD',
+        FRXBROUSD: 'Oil/USD',
+        FRXEURAUD: 'EUR/AUD',
+        FRXEURCAD: 'EUR/CAD',
+        FRXEURCHF: 'EUR/CHF',
+        FRXEURGBP: 'EUR/GBP',
+        FRXEURJPY: 'EUR/JPY',
+        FRXEURNZD: 'EUR/NZD',
+        FRXEURUSD: 'EUR/USD',
+        FRXGBPAUD: 'GBP/AUD',
+        FRXGBPCAD: 'GBP/CAD',
+        FRXGBPCHF: 'GBP/CHF',
+        FRXGBPJPY: 'GBP/JPY',
+        FRXGBPNOK: 'GBP/NOK',
+        FRXGBPUSD: 'GBP/USD',
+        FRXNZDJPY: 'NZD/JPY',
+        FRXNZDUSD: 'NZD/USD',
+        FRXUSDCAD: 'USD/CAD',
+        FRXUSDCHF: 'USD/CHF',
+        FRXUSDJPY: 'USD/JPY',
+        FRXUSDNOK: 'USD/NOK',
+        FRXUSDPLN: 'USD/PLN',
+        FRXUSDSEK: 'USD/SEK',
+        FRXXAGUSD: 'Silver/USD',
+        FRXXAUUSD: 'Gold/USD',
+        FRXXPDUSD: 'Palladium/USD',
+        FRXXPTUSD: 'Platinum/USD',
+        WLDXAU: 'Gold Basket',
+        OTC_AEX: 'Netherlands 25',
+        OTC_AS51: 'Australia 200',
+        OTC_DJI: 'Wall Street 30',
+        OTC_FCHI: 'France 40',
+        OTC_FTSE: 'UK 100',
+        OTC_GDAXI: 'Germany 40',
+        OTC_HSI: 'Hong Kong 50',
+        OTC_IBEX35: 'Spain 35',
+        OTC_N225: 'Japan 225',
+        OTC_NDX: 'US Tech 100',
+        OTC_SPC: 'US 500',
+        OTC_SPX500: 'US 500',
+        OTC_SSMI: 'Swiss 20',
+        OTC_SX5E: 'Euro 50',
+        R_10: 'Volatility 10 Index',
+        R_25: 'Volatility 25 Index',
+        R_50: 'Volatility 50 Index',
+        R_75: 'Volatility 75 Index',
+        R_100: 'Volatility 100 Index',
+        BOOM300N: 'Boom 300 Index',
+        BOOM500: 'Boom 500 Index',
+        BOOM1000: 'Boom 1000 Index',
+        CRASH300N: 'Crash 300 Index',
+        CRASH500: 'Crash 500 Index',
+        CRASH1000: 'Crash 1000 Index',
+        RDBEAR: 'Bear Market Index',
+        RDBULL: 'Bull Market Index',
+        STPRNG: 'Step Index',
+        WLDAUD: 'AUD Basket',
+        WLDEUR: 'EUR Basket',
+        WLDGBP: 'GBP Basket',
+        WLDUSD: 'USD Basket',
+        '1HZ10V': 'Volatility 10 (1s) Index',
+        '1HZ15V': 'Volatility 15 (1s) Index',
+        '1HZ25V': 'Volatility 25 (1s) Index',
+        '1HZ30V': 'Volatility 30 (1s) Index',
+        '1HZ50V': 'Volatility 50 (1s) Index',
+        '1HZ75V': 'Volatility 75 (1s) Index',
+        '1HZ90V': 'Volatility 90 (1s) Index',
+        '1HZ100V': 'Volatility 100 (1s) Index',
+        '1HZ150V': 'Volatility 150 (1s) Index',
+        '1HZ200V': 'Volatility 200 (1s) Index',
+        '1HZ250V': 'Volatility 250 (1s) Index',
+        '1HZ300V': 'Volatility 300 (1s) Index',
+        JD10: 'Jump 10 Index',
+        JD25: 'Jump 25 Index',
+        JD50: 'Jump 50 Index',
+        JD75: 'Jump 75 Index',
+        JD100: 'Jump 100 Index',
+        JD150: 'Jump 150 Index',
+        JD200: 'Jump 200 Index',
+        CRYBCHUSD: 'BCH/USD',
+        CRYBNBUSD: 'BNB/USD',
+        CRYBTCLTC: 'BTC/LTC',
+        CRYIOTUSD: 'IOT/USD',
+        CRYNEOUSD: 'NEO/USD',
+        CRYOMGUSD: 'OMG/USD',
+        CRYTRXUSD: 'TRX/USD',
+        CRYBTCETH: 'BTC/ETH',
+        CRYZECUSD: 'ZEC/USD',
+        CRYXMRUSD: 'ZMR/USD',
+        CRYXMLUSD: 'XLM/USD',
+        CRYXRPUSD: 'XRP/USD',
+        CRYBTCUSD: 'BTC/USD',
+        CRYDSHUSD: 'DSH/USD',
+        CRYETHUSD: 'ETH/USD',
+        CRYEOSUSD: 'EOS/USD',
+        CRYLTCUSD: 'LTC/USD',
     }) as const;
 
 export const getUnsupportedContracts = () =>
     ({
         CALLSPREAD: {
-            name: localize('Spread Up'),
+            name: 'Spread Up',
             position: 'top',
         },
         PUTSPREAD: {
-            name: localize('Spread Down'),
+            name: 'Spread Down',
             position: 'bottom',
         },
     }) as const;
@@ -205,146 +202,146 @@ export const getUnsupportedContracts = () =>
 export const getSupportedContracts = (is_high_low?: boolean) =>
     ({
         [CONTRACT_TYPES.ACCUMULATOR]: {
-            button_name: localize('Buy'),
-            name: localize('Accumulators'),
+            button_name: 'Buy',
+            name: 'Accumulators',
             position: 'top',
         },
         [CONTRACT_TYPES.CALL]: {
-            name: is_high_low ? localize('Higher') : localize('Rise'),
+            name: is_high_low ? 'Higher' : 'Rise',
             position: 'top',
         },
         [CONTRACT_TYPES.PUT]: {
-            name: is_high_low ? localize('Lower') : localize('Fall'),
+            name: is_high_low ? 'Lower' : 'Fall',
             position: 'bottom',
         },
         [CONTRACT_TYPES.CALLE]: {
-            name: localize('Rise'),
+            name: 'Rise',
             position: 'top',
         },
         [CONTRACT_TYPES.PUTE]: {
-            name: localize('Fall'),
+            name: 'Fall',
             position: 'bottom',
         },
         [CONTRACT_TYPES.MATCH_DIFF.MATCH]: {
-            name: localize('Matches'),
+            name: 'Matches',
             position: 'top',
         },
         [CONTRACT_TYPES.MATCH_DIFF.DIFF]: {
-            name: localize('Differs'),
+            name: 'Differs',
             position: 'bottom',
         },
         [CONTRACT_TYPES.EVEN_ODD.EVEN]: {
-            name: localize('Even'),
+            name: 'Even',
             position: 'top',
         },
         [CONTRACT_TYPES.EVEN_ODD.ODD]: {
-            name: localize('Odd'),
+            name: 'Odd',
             position: 'bottom',
         },
         [CONTRACT_TYPES.OVER_UNDER.OVER]: {
-            name: localize('Over'),
+            name: 'Over',
             position: 'top',
         },
         [CONTRACT_TYPES.OVER_UNDER.UNDER]: {
-            name: localize('Under'),
+            name: 'Under',
             position: 'bottom',
         },
         [CONTRACT_TYPES.TOUCH.ONE_TOUCH]: {
-            name: localize('Touch'),
+            name: 'Touch',
             position: 'top',
         },
         [CONTRACT_TYPES.TOUCH.NO_TOUCH]: {
-            name: localize('No Touch'),
+            name: 'No Touch',
             position: 'bottom',
         },
         [CONTRACT_TYPES.MULTIPLIER.UP]: {
-            name: localize('Up'),
+            name: 'Up',
             position: 'top',
-            main_title: localize('Multipliers'),
+            main_title: 'Multipliers',
         },
         [CONTRACT_TYPES.MULTIPLIER.DOWN]: {
-            name: localize('Down'),
+            name: 'Down',
             position: 'bottom',
-            main_title: localize('Multipliers'),
+            main_title: 'Multipliers',
         },
         [CONTRACT_TYPES.TURBOS.LONG]: {
-            name: localize('Up'),
+            name: 'Up',
             position: 'top',
-            main_title: localize('Turbos'),
+            main_title: 'Turbos',
         },
         [CONTRACT_TYPES.TURBOS.SHORT]: {
-            name: localize('Down'),
+            name: 'Down',
             position: 'bottom',
-            main_title: localize('Turbos'),
+            main_title: 'Turbos',
         },
         [CONTRACT_TYPES.VANILLA.CALL]: {
-            name: localize('Call'),
+            name: 'Call',
             position: 'top',
-            main_title: localize('Vanillas'),
+            main_title: 'Vanillas',
         },
         [CONTRACT_TYPES.VANILLA.PUT]: {
-            name: localize('Put'),
+            name: 'Put',
             position: 'bottom',
-            main_title: localize('Vanillas'),
+            main_title: 'Vanillas',
         },
         [CONTRACT_TYPES.RUN_HIGH_LOW.HIGH]: {
-            name: localize('Only Ups'),
+            name: 'Only Ups',
             position: 'top',
         },
         [CONTRACT_TYPES.RUN_HIGH_LOW.LOW]: {
-            name: localize('Only Downs'),
+            name: 'Only Downs',
             position: 'bottom',
         },
         [CONTRACT_TYPES.END.OUT]: {
-            name: localize('Ends Outside'),
+            name: 'Ends Outside',
             position: 'top',
         },
         [CONTRACT_TYPES.END.IN]: {
-            name: localize('Ends Between'),
+            name: 'Ends Between',
             position: 'bottom',
         },
         [CONTRACT_TYPES.STAY.IN]: {
-            name: localize('Stays Between'),
+            name: 'Stays Between',
             position: 'top',
         },
         [CONTRACT_TYPES.STAY.OUT]: {
-            name: localize('Goes Outside'),
+            name: 'Goes Outside',
             position: 'bottom',
         },
         [CONTRACT_TYPES.ASIAN.UP]: {
-            name: localize('Asian Up'),
+            name: 'Asian Up',
             position: 'top',
         },
         [CONTRACT_TYPES.ASIAN.DOWN]: {
-            name: localize('Asian Down'),
+            name: 'Asian Down',
             position: 'bottom',
         },
         [CONTRACT_TYPES.TICK_HIGH_LOW.HIGH]: {
-            name: localize('High Tick'),
+            name: 'High Tick',
             position: 'top',
         },
         [CONTRACT_TYPES.TICK_HIGH_LOW.LOW]: {
-            name: localize('Low Tick'),
+            name: 'Low Tick',
             position: 'bottom',
         },
         [CONTRACT_TYPES.RESET.CALL]: {
-            name: localize('Reset Call'),
+            name: 'Reset Call',
             position: 'top',
         },
         [CONTRACT_TYPES.RESET.PUT]: {
-            name: localize('Reset Put'),
+            name: 'Reset Put',
             position: 'bottom',
         },
         [CONTRACT_TYPES.LB_CALL]: {
-            name: localize('Close-Low'),
+            name: 'Close-Low',
             position: 'top',
         },
         [CONTRACT_TYPES.LB_PUT]: {
-            name: localize('High-Close'),
+            name: 'High-Close',
             position: 'top',
         },
         [CONTRACT_TYPES.LB_HIGH_LOW]: {
-            name: localize('High-Low'),
+            name: 'High-Low',
             position: 'top',
         },
     }) as const;
diff --git a/src/external/bot-skeleton/constants/config.ts b/src/external/bot-skeleton/constants/config.ts
index 5f4e5ab4..5b9a3607 100644
--- a/src/external/bot-skeleton/constants/config.ts
+++ b/src/external/bot-skeleton/constants/config.ts
@@ -1,51 +1,53 @@
+import { localize } from '@deriv-com/translations';
+
 const CRYPTO_CURRENCIES = ['BTC', 'ETH', 'LTC', 'BCH', 'UST'];
 
 export const config = () => ({
     lists: {
         PAYOUTTYPE: [
-            // ['Payout', 'payout'],
-            ['Stake', 'stake'],
+            // [localize('Payout'), 'payout'],
+            [localize('Stake'), 'stake'],
         ],
         CRYPTO_CURRENCIES,
         DETAILS: [
-            ['deal reference id', '1'],
-            ['purchase price', '2'],
-            ['payout', '3'],
-            ['profit', '4'],
-            ['contract type', '5'],
-            ['entry spot time', '6'],
-            ['entry spot price', '7'],
-            ['exit spot time', '8'],
-            ['exit spot price', '9'],
-            ['barrier', '10'],
-            ['result', '11'],
+            [localize('deal reference id'), '1'],
+            [localize('purchase price'), '2'],
+            [localize('payout'), '3'],
+            [localize('profit'), '4'],
+            [localize('contract type'), '5'],
+            [localize('entry spot time'), '6'],
+            [localize('entry spot price'), '7'],
+            [localize('exit spot time'), '8'],
+            [localize('exit spot price'), '9'],
+            [localize('barrier'), '10'],
+            [localize('result'), '11'],
         ],
         CHECK_RESULT: [
-            ['Win', 'win'],
-            ['Loss', 'loss'],
+            [localize('Win'), 'win'],
+            [localize('Loss'), 'loss'],
         ],
         CHECK_DIRECTION: [
-            ['Rise', 'rise'],
-            ['Fall', 'fall'],
-            ['No Change', ''],
+            [localize('Rise'), 'rise'],
+            [localize('Fall'), 'fall'],
+            [localize('No Change'), ''],
         ],
         BALANCE_TYPE: [
-            ['string', 'STR'],
-            ['number', 'NUM'],
+            [localize('string'), 'STR'],
+            [localize('number'), 'NUM'],
         ],
         NOTIFICATION_TYPE: [
-            ['green', 'success'],
-            ['blue', 'info'],
-            ['yellow', 'warn'],
-            ['red', 'error'],
+            [localize('green'), 'success'],
+            [localize('blue'), 'info'],
+            [localize('yellow'), 'warn'],
+            [localize('red'), 'error'],
         ],
         NOTIFICATION_SOUND: [
-            ['Silent', 'silent'],
-            ['Announcement', 'announcement'],
-            ['Earned money', 'earned-money'],
-            ['Job done', 'job-done'],
-            ['Error', 'error'],
-            ['Severe error', 'severe-error'],
+            [localize('Silent'), 'silent'],
+            [localize('Announcement'), 'announcement'],
+            [localize('Earned money'), 'earned-money'],
+            [localize('Job done'), 'job-done'],
+            [localize('Error'), 'error'],
+            [localize('Severe error'), 'severe-error'],
         ],
         CURRENCY: ['USD', 'EUR', 'GBP', 'AUD', ...CRYPTO_CURRENCIES],
     },
@@ -188,19 +190,19 @@ export const config = () => ({
         ['Open Time', 'epoch'],
     ],
     candleIntervals: [
-        ['Default', 'default'],
-        ['1 minute', '60'],
-        ['2 minutes', '120'],
-        ['3 minutes', '180'],
-        ['5 minutes', '300'],
-        ['10 minutes', '600'],
-        ['15 minutes', '900'],
-        ['30 minutes', '1800'],
-        ['1 hour', '3600'],
-        ['2 hours', '7200'],
-        ['4 hours', '14400'],
-        ['8 hours', '28800'],
-        ['1 day', '86400'],
+        [localize('Default'), 'default'],
+        [localize('1 minute'), '60'],
+        [localize('2 minutes'), '120'],
+        [localize('3 minutes'), '180'],
+        [localize('5 minutes'), '300'],
+        [localize('10 minutes'), '600'],
+        [localize('15 minutes'), '900'],
+        [localize('30 minutes'), '1800'],
+        [localize('1 hour'), '3600'],
+        [localize('2 hours'), '7200'],
+        [localize('4 hours'), '14400'],
+        [localize('8 hours'), '28800'],
+        [localize('1 day'), '86400'],
     ],
     mainBlocks: ['trade_definition', 'before_purchase', 'during_purchase', 'after_purchase'],
     mandatoryMainBlocks: ['trade_definition', 'purchase', 'before_purchase'],
@@ -248,29 +250,29 @@ export const config = () => ({
         accumulator: ['accumulator'],
     },
     DEFAULT_DURATION_DROPDOWN_OPTIONS: [
-        ['Ticks', 't'],
-        ['Seconds', 's'],
-        ['Minutes', 'm'],
-        ['Hours', 'h'],
-        ['Days', 'd'],
+        [localize('Ticks'), 't'],
+        [localize('Seconds'), 's'],
+        [localize('Minutes'), 'm'],
+        [localize('Hours'), 'h'],
+        [localize('Days'), 'd'],
     ],
-    BARRIER_LABELS: ['High barrier', 'Low barrier'],
-    ABSOLUTE_BARRIER_DROPDOWN_OPTION: [['Absolute', 'absolute']],
-    NOT_AVAILABLE_DROPDOWN_OPTIONS: [['Not available', 'na']],
-    NOT_AVAILABLE_DURATIONS: [{ display: 'Not available', unit: 'na', min: 0 }],
+    BARRIER_LABELS: [localize('High barrier'), localize('Low barrier')],
+    ABSOLUTE_BARRIER_DROPDOWN_OPTION: [[localize('Absolute'), 'absolute']],
+    NOT_AVAILABLE_DROPDOWN_OPTIONS: [[localize('Not available'), 'na']],
+    NOT_AVAILABLE_DURATIONS: [{ display: localize('Not available'), unit: 'na', min: 0 }],
     BARRIER_TRADE_TYPES: ['higherlower', 'touchnotouch', 'endsinout', 'staysinout', 'callputspread'],
     PREDICTION_TRADE_TYPES: ['matchesdiffers', 'overunder', 'highlowticks'],
     DIGIT_CATEGORIES: ['digits', 'highlowticks'],
     INDEPEDENT_BLOCKS: ['block_holder', 'tick_analysis', 'loader', 'procedures_defreturn', 'procedures_defnoreturn'],
     bbResult: [
-        ['upper', '1'],
-        ['middle', '0'],
-        ['lower', '2'],
+        [localize('upper'), '1'],
+        [localize('middle'), '0'],
+        [localize('lower'), '2'],
     ],
     macdFields: [
-        ['Histogram', '0'],
-        ['MACD', '1'],
-        ['Signal', '2'],
+        [localize('Histogram'), '0'],
+        [localize('MACD'), '1'],
+        [localize('Signal'), '2'],
     ],
     GOOGLE_DRIVE: {
         SCOPE: 'https://www.googleapis.com/auth/drive.file',
@@ -285,21 +287,27 @@ export const config = () => ({
     strategies: {
         martingale: {
             index: 0,
-            label: 'Martingale',
-            description: 'The Martingale Strategy is a classic trading technique that has been used for more than a hundred years, popularised by the French mathematician Paul Pierre Levy in the 18th century.',
+            label: localize('Martingale'),
+            description: localize(
+                'The Martingale Strategy is a classic trading technique that has been used for more than a hundred years, popularised by the French mathematician Paul Pierre Levy in the 18th century.'
+            ),
         },
         dalembert: {
             index: 1,
-            label: "D'Alembert",
-            description: "The concept of the D'Alembert Strategy is said to be similar to the Martingale Strategy where you will increase your contract size after a loss. With the D'Alembert Strategy, you will also decrease your contract size after a successful trade.",
+            label: localize("D'Alembert"),
+            description: localize(
+                'The concept of the D’Alembert Strategy is said to be similar to the Martingale Strategy where you will increase your contract size after a loss. With the D’Alembert Strategy, you will also decrease your contract size after a successful trade.'
+            ),
         },
         oscars_grind: {
             index: 2,
-            label: "Oscar's Grind",
-            description: "The Oscar's Grind Strategy is a low-risk positive progression strategy that first appeared in 1965. By using this strategy, the size of your contract will increase after successful trades, but remains unchanged after unsuccessful trades.",
+            label: localize("Oscar's Grind"),
+            description: localize(
+                "The Oscar's Grind Strategy is a low-risk positive progression strategy that first appeared in 1965. By using this strategy, the size of your contract will increase after successful trades, but remains unchanged after unsuccessful trades."
+            ),
         },
     },
-    default_file_name: 'Untitled Bot',
+    default_file_name: localize('Untitled Bot'),
     DISABLED_SYMBOLS: ['frxGBPNOK', 'frxUSDNOK', 'frxUSDNEK', 'frxUSDSEK'],
     DISABLED_SUBMARKETS: ['energy'],
     QUICK_STRATEGY: {
@@ -326,3 +334,4 @@ export const config = () => ({
         },
     },
 });
+