beta to master

src/botPage/bot/Interpreter.js

@@ -12,14 +12,16 @@ const unrecoverableErrors = [
     'NotDefaultCurrency',
     'PleaseAuthenticate',
     'FinancialAssessmentRequired',
+    'AuthorizationRequired',
+    'InvalidToken',
 ];
 const botInitialized = bot => bot && bot.tradeEngine.options;
 const botStarted = bot => botInitialized(bot) && bot.tradeEngine.tradeOptions;
 const shouldRestartOnError = (bot, errorName = '') =>
     !unrecoverableErrors.includes(errorName) && botInitialized(bot) && bot.tradeEngine.options.shouldRestartOnError;
 
 const shouldStopOnError = (bot, errorName = '') => {
-    const stopErrors = ['SellNotAvailable'];
+    const stopErrors = ['SellNotAvailableCustom'];
     if (stopErrors.includes(errorName) && botInitialized(bot)) {
         return true;
     }

src/botPage/bot/TradeEngine/OpenContract.js

@@ -2,6 +2,7 @@ import { roundBalance } from '../../common/tools';
 import { doUntilDone } from '../tools';
 import { contractStatus, contractSettled, contract as broadcastContract } from '../broadcast';
 import { sell, openContractReceived } from './state/actions';
+import { observer } from '../../../common/utils/observer';
 
 const AFTER_FINISH_TIMEOUT = 5;
 
@@ -43,7 +44,6 @@ export default Engine =>
                     this.store.dispatch(openContractReceived());
                     if (!this.isExpired) {
                         this.resetSubscriptionTimeout();
-
                     }
                 }
             });
@@ -61,10 +61,13 @@ export default Engine =>
 
             this.unsubscribeOpenContract();
 
-            doUntilDone(() => this.api.subscribeToOpenContract(contractId)).then(r => {
-                ({
-                    proposal_open_contract: { id: this.openContractId },
-                } = r);
+            doUntilDone(() =>
+                this.api.subscribeToOpenContract(contractId).then(response => {
+                    this.openContractId = response.proposal_open_contract.id;
+                })
+            ).catch(error => {
+                observer.emit('reset_animation');
+                observer.emit('Error', error);
             });
         }
         resetSubscriptionTimeout(timeout = this.getContractDuration() + AFTER_FINISH_TIMEOUT) {

src/botPage/bot/TradeEngine/Proposal.js

@@ -1,5 +1,5 @@
 import { translate } from '../../../common/i18n';
-import { tradeOptionToProposal, doUntilDone, getUUID } from '../tools';
+import { tradeOptionToProposal, doUntilDone } from '../tools';
 import { proposalsReady, clearProposals } from './state/actions';
 
 export default Engine =>
@@ -49,13 +49,7 @@ export default Engine =>
             this.proposalTemplates.map(proposal =>
                 doUntilDone(() =>
                     this.api
-                        .subscribeToPriceForContractProposal({
-                            ...proposal,
-                            passthrough: {
-                                contractType: proposal.contract_type,
-                                uuid        : getUUID(),
-                            },
-                        })
+                        .subscribeToPriceForContractProposal(proposal)
                         // eslint-disable-next-line consistent-return
                         .catch(e => {
                             if (e && e.name === 'RateLimit') {
@@ -127,8 +121,14 @@ export default Engine =>
         checkProposalReady() {
             const proposals = this.data.get('proposals');
 
-            if (proposals && proposals.size === this.proposalTemplates.length) {
-                this.startPromise.then(() => this.store.dispatch(proposalsReady()));
+            if (proposals && proposals.size) {
+                const isSameWithTemplate = this.proposalTemplates.every(p =>
+                    this.data.hasIn(['proposals', p.passthrough.uuid])
+                );
+
+                if (isSameWithTemplate) {
+                    this.startPromise.then(() => this.store.dispatch(proposalsReady()));
+                }
             }
         }
         isNewTradeOption(tradeOption) {

src/botPage/bot/TradeEngine/Sell.js

@@ -17,26 +17,43 @@ export default Engine =>
             }
 
             if (!this.isSellAtMarketAvailable()) {
-                if (this.hasEntryTick) {
-                    const error = new Error(translate('Resale of this contract is not offered.'));
-                    error.name = 'SellNotAvailable';
-                    throw error;
-                } else {
-                    return Promise.resolve();
-                }
+                notify('warn', translate('Resale of this contract is not offered.'));
+                return Promise.resolve();
             }
 
-            const onSuccess = ({ sell: { sold_for: soldFor } }) => {
+            const onSuccess = soldFor => {
                 delayIndex = 0;
                 contractStatus('purchase.sold');
                 notify('info', `${translate('Sold for')}: ${soldFor}`);
                 return this.waitForAfter();
             };
 
-            const action = () => this.api.sellContract(this.contractId, 0);
+            const action = () =>
+                this.api
+                    .sellContract(this.contractId, 0)
+                    .then(response => {
+                        onSuccess(response.sell.sold_for);
+                    })
+                    .catch(response => {
+                        const {
+                            error: { error },
+                        } = response;
+                        if (error.code === 'InvalidOfferings') {
+                            // "InvalidOfferings" may occur when user tries to sell the contract too close
+                            // to the expiry time. We shouldn't interrupt the bot but instead let the contract
+                            // finish.
+                            notify('warn', error.message);
+                            return Promise.resolve();
+                        }
+                        // In all other cases, throw a custom error that will stop the bot (after the current contract has finished).
+                        // See interpreter for SellNotAvailableCustom.
+                        const customError = new Error(error.message);
+                        customError.name = 'SellNotAvailableCustom';
+                        throw customError;
+                    });
 
             if (!this.options.timeMachineEnabled) {
-                return doUntilDone(action).then(onSuccess);
+                return doUntilDone(action);
             }
 
             return recoverFromError(

src/botPage/bot/tools.js

@@ -15,6 +15,10 @@ export const tradeOptionToProposal = tradeOption =>
             duration     : tradeOption.duration,
             amount       : roundBalance({ currency: tradeOption.currency, balance: tradeOption.amount }),
             contract_type: type,
+            passthrough  : {
+                contractType: type,
+                uuid        : getUUID(),
+            },
         };
         if (tradeOption.prediction !== undefined) {
             proposal.selected_tick = tradeOption.prediction;

src/botPage/common/const.js

@@ -232,6 +232,7 @@ const config = {
         aid: 'derivbot-248506',
         api: 'AIzaSyBDYQ7IIgGxM14IeAV5JrtaJNYjxB4A5jo',
     },
+    quick_strategies: ['martingale', 'dalembert'],
 };
 
 export async function updateConfigCurrencies() {

src/botPage/common/error.js

@@ -1,13 +1,6 @@
-import { observer as globalObserver } from '../../common/utils/observer';
-import { translate } from '../../common/i18n';
-
+/* eslint-disable import/prefer-default-export */
 export const createError = (name, message) => {
     const e = new Error(message);
     e.name = name;
     return e;
 };
-
-export const createErrorAndEmit = (name, message) => {
-    globalObserver.emit('ui.log.warn', `${translate(message)}`);
-    return createError(name, message);
-};

src/botPage/view/TradeInfoPanel/index.js

@@ -50,6 +50,10 @@ class AnimateTrade extends Component {
             $('.stage-tooltip.top:eq(0)').removeClass('running');
             this.setState({ indicatorMessage: this.indicatorMessages.stopped });
         });
+        globalObserver.register('reset_animation', () => {
+            resetAnimation();
+            this.setState({ indicatorMessage: this.indicatorMessages.stopped });
+        });
 
         $('#stopButton').click(() => {
             $('.stage-tooltip.top:eq(0)').removeClass('running');

src/botPage/view/blockly/index.js

@@ -18,15 +18,17 @@ import {
     saveBeforeUnload,
     removeParam,
     updateRenamedFields,
+    getPreviousStrat,
 } from './utils';
 import Interpreter from '../../bot/Interpreter';
-import { createErrorAndEmit } from '../../common/error';
 import { translate, xml as translateXml } from '../../../common/i18n';
 import { getLanguage } from '../../../common/lang';
 import { observer as globalObserver } from '../../../common/utils/observer';
 import { showDialog } from '../../bot/tools';
 import GTM from '../../../common/gtm';
 import { parseQueryString } from '../../../common/utils/tools';
+import { TrackJSError } from '../logger';
+import config from '../../common/const';
 
 const disableStrayBlocks = () => {
     const topBlocks = Blockly.mainWorkspace.getTopBlocks();
@@ -180,20 +182,29 @@ export const load = (blockStr, dropEvent = {}) => {
             throw new Error();
         }
     } catch (err) {
-        throw createErrorAndEmit('FileLoad', unrecognisedMsg());
+        const error = new TrackJSError('FileLoad', unrecognisedMsg(), err);
+        globalObserver.emit('Error', error);
+        return;
     }
 
     let xml;
     try {
         xml = Blockly.Xml.textToDom(blockStr);
     } catch (e) {
-        throw createErrorAndEmit('FileLoad', unrecognisedMsg());
+        const error = new TrackJSError('FileLoad', unrecognisedMsg(), e);
+        globalObserver.emit('Error', error);
+        return;
     }
 
     const blocklyXml = xml.querySelectorAll('block');
 
     if (!blocklyXml.length) {
-        throw createErrorAndEmit('FileLoad', 'XML file contains unsupported elements. Please check or modify file.');
+        const error = new TrackJSError(
+            'FileLoad',
+            translate('XML file contains unsupported elements. Please check or modify file.')
+        );
+        globalObserver.emit('Error', error);
+        return;
     }
 
     if (xml.hasAttribute('is_dbot')) {
@@ -227,7 +238,12 @@ export const load = (blockStr, dropEvent = {}) => {
         const blockType = block.getAttribute('type');
 
         if (!Object.keys(Blockly.Blocks).includes(blockType)) {
-            throw createErrorAndEmit('FileLoad', 'XML file contains unsupported elements. Please check or modify file');
+            const error = new TrackJSError(
+                'FileLoad',
+                translate('XML file contains unsupported elements. Please check or modify file.')
+            );
+            globalObserver.emit('Error', error);
+            throw error;
         }
     });
 
@@ -240,7 +256,8 @@ export const load = (blockStr, dropEvent = {}) => {
             loadWorkspace(xml);
         }
     } catch (e) {
-        throw createErrorAndEmit('FileLoad', translate('Unable to load the block file'));
+        const error = new TrackJSError('FileLoad', translate('Unable to load the block file'), e);
+        globalObserver.emit('Error', error);
     }
 };
 
@@ -343,9 +360,6 @@ export default class _Blockly {
                 window.addEventListener('resize', renderInstance, false);
                 renderInstance();
                 addBlocklyTranslation().then(() => {
-                    const defaultStrat = parseQueryString().strategy;
-                    const xmlFile = `xml/${defaultStrat}.xml`;
-
                     const loadDomToWorkspace = dom => {
                         repaintDefaultColours();
                         overrideBlocklyDefaultShape();
@@ -359,29 +373,27 @@ export default class _Blockly {
                         }, 0);
                     };
 
+                    let defaultStrat = parseQueryString().strategy;
+
+                    if (!defaultStrat || !config.quick_strategies.includes(defaultStrat)) {
+                        const previousStrat = getPreviousStrat();
+
+                        if (previousStrat) {
+                            const previousStratDOM = Blockly.Xml.textToDom(previousStrat);
+                            loadDomToWorkspace(previousStratDOM);
+                            resolve();
+                            return;
+                        }
+
+                        defaultStrat = 'main';
+                    }
+
+                    const xmlFile = `xml/${defaultStrat}.xml`;
                     const getFile = xml => {
-                        importFile(xml)
-                            .then(dom => {
-                                loadDomToWorkspace(dom.getElementsByTagName('xml')[0]);
-                                resolve();
-                            })
-                            .catch(text => {
-                                if (text) {
-                                    const previousStrat = Blockly.Xml.textToDom(text);
-                                    loadDomToWorkspace(previousStrat);
-                                    resolve();
-                                } else {
-                                    getFile('xml/main.xml');
-                                }
-
-                                if (defaultStrat) {
-                                    globalObserver.emit('Notify', {
-                                        className: 'warn',
-                                        message  : translate('The strategy you tried to load is invalid'),
-                                        position : 'right',
-                                    });
-                                }
-                            });
+                        importFile(xml).then(dom => {
+                            loadDomToWorkspace(dom.getElementsByTagName('xml')[0]);
+                            resolve();
+                        });
                     };
 
                     getFile(xmlFile);

src/botPage/view/blockly/utils.js

@@ -3,6 +3,7 @@ import { saveAs } from '../shared';
 import config from '../../common/const';
 import { translate } from '../../../common/i18n';
 import { observer as globalObserver } from '../../../common/utils/observer';
+import { TrackJSError } from '../logger';
 
 export const isMainBlock = blockType => config.mainBlocks.indexOf(blockType) >= 0;
 
@@ -97,12 +98,8 @@ export const strategyHasValidTradeTypeCategory = xml => {
         return false;
     });
     if (!validTradeTypeCategory) {
-        const errorMessage = translate('The strategy you tried to import is invalid.');
-        globalObserver.emit('ui.log.error', errorMessage);
-
-        if (window.trackJs) {
-            trackJs.track(errorMessage);
-        }
+        const error = new TrackJSError('FileLoad', translate('The strategy you tried to import is invalid.'));
+        globalObserver.emit('Error', error);
     }
     return validTradeTypeCategory;
 };
@@ -574,3 +571,5 @@ export const removeParam = key => {
 
     window.history.pushState({}, window.title, rtn);
 };
+
+export const getPreviousStrat = () => localStorage.getItem('previousStrat');