aaron/TrackJS continued

src/botPage/bot/Interpreter.js

@@ -8,7 +8,6 @@ const unrecoverableErrors = [
     'CustomLimitsReached',
     'OfferingsValidationError',
     'InvalidCurrency',
-    'ContractBuyValidationError',
     'NotDefaultCurrency',
     'PleaseAuthenticate',
     'FinancialAssessmentRequired',

src/botPage/bot/TradeEngine/Proposal.js

@@ -1,6 +1,7 @@
 import { translate } from '../../../common/i18n';
 import { tradeOptionToProposal, doUntilDone } from '../tools';
 import { proposalsReady, clearProposals } from './state/actions';
+import { TrackJSError } from '../../view/logger';
 
 export default Engine =>
     class Proposal extends Engine {
@@ -22,15 +23,20 @@ export default Engine =>
             this.data.get('proposals').forEach(proposal => {
                 if (proposal.contractType === contractType) {
                     if (proposal.error) {
-                        throw Error(proposal.error.error.error.message);
+                        const { error } = proposal.error;
+                        throw new TrackJSError(error.error.code, error.error.message, error);
                     } else {
                         toBuy = proposal;
                     }
                 }
             });
 
             if (!toBuy) {
-                throw Error(translate('Selected proposal does not exist'));
+                throw new TrackJSError(
+                    'CustomInvalidProposal',
+                    translate('Selected proposal does not exist'),
+                    Array.from(this.data.get('proposals')).map(proposal => proposal[1])
+                );
             }
 
             return {
@@ -46,14 +52,12 @@ export default Engine =>
             this.store.dispatch(clearProposals());
         }
         requestProposals() {
-            this.proposalTemplates.map(proposal =>
-                doUntilDone(() =>
-                    this.api
-                        .subscribeToPriceForContractProposal(proposal)
-                        // eslint-disable-next-line consistent-return
-                        .catch(e => {
+            Promise.all(
+                this.proposalTemplates.map(proposal =>
+                    doUntilDone(() =>
+                        this.api.subscribeToPriceForContractProposal(proposal).catch(e => {
                             if (e && e.name === 'RateLimit') {
-                                return Promise.reject(e);
+                                throw e;
                             }
 
                             const errorCode = e.error && e.error.error && e.error.error.code;
@@ -62,18 +66,22 @@ export default Engine =>
                                 const { uuid } = e.error.echo_req.passthrough;
 
                                 if (!this.data.hasIn(['forgetProposals', uuid])) {
+                                    // Add to proposals map with error. Will later be shown to user, see selectProposal.
                                     this.data = this.data.setIn(['proposals', uuid], {
                                         ...proposal,
-                                        contractType: proposal.contract_type,
-                                        error       : e,
+                                        ...proposal.passthrough,
+                                        error: e,
                                     });
                                 }
-                            } else {
-                                this.$scope.observer.emit('Error', e);
+
+                                return null;
                             }
+
+                            throw e;
                         })
+                    )
                 )
-            );
+            ).catch(e => this.$scope.observer.emit('Error', e));
         }
         observeProposals() {
             this.listen('proposal', r => {

src/botPage/bot/tools.js

@@ -99,12 +99,29 @@ const getBackoffDelay = (error, delayIndex) => {
     return linearIncrease * 1000;
 };
 
-export const shouldThrowError = (e, types = [], delayIndex = 0) =>
-    e &&
-    (!types
-        .concat(['CallError', 'WrongResponse', 'GetProposalFailure', 'RateLimit', 'DisconnectError'])
-        .includes(e.name) ||
-        (e.name !== 'DisconnectError' && delayIndex > maxRetries));
+export const shouldThrowError = (error, types = [], delayIndex = 0) => {
+    if (!error) {
+        return false;
+    }
+
+    const defaultErrors = ['CallError', 'WrongResponse', 'GetProposalFailure', 'RateLimit', 'DisconnectError'];
+    const authErrors = ['InvalidToken', 'AuthorizationRequired'];
+    const errors = types.concat(defaultErrors);
+
+    if (authErrors.includes(error.name)) {
+        // If auth error, reload page.
+        window.location.reload();
+        return true;
+    } else if (!errors.includes(error.name)) {
+        // If error is unrecoverable, throw error.
+        return true;
+    } else if (error.name !== 'DisconnectError' && delayIndex > maxRetries) {
+        // If exceeded maxRetries, throw error.
+        return true;
+    }
+
+    return false;
+};
 
 export const recoverFromError = (f, r, types, delayIndex) =>
     new Promise((resolve, reject) => {

src/botPage/view/LogTable.js

@@ -24,7 +24,7 @@ export default class LogTable extends Component {
             type     : PropTypes.string,
             timestamp: PropTypes.string,
             message  : PropTypes.string,
-        }).isRequired,
+        }),
     };
     constructor() {
         super();