dev to beta

src/botPage/bot/TradeEngine/Proposal.js

@@ -21,7 +21,11 @@ export default Engine =>
 
             this.data.get('proposals').forEach(proposal => {
                 if (proposal.contractType === contractType) {
-                    toBuy = proposal;
+                    if (proposal.error) {
+                        throw Error(proposal.error.error.error.message);
+                    } else {
+                        toBuy = proposal;
+                    }
                 }
             });
 
@@ -42,19 +46,33 @@ export default Engine =>
             this.store.dispatch(clearProposals());
         }
         requestProposals() {
-            Promise.all(
-                this.proposalTemplates.map(proposal =>
-                    doUntilDone(() =>
-                        this.api.subscribeToPriceForContractProposal({
+            this.proposalTemplates.map(proposal =>
+                doUntilDone(() =>
+                    this.api
+                        .subscribeToPriceForContractProposal({
                             ...proposal,
                             passthrough: {
                                 contractType: proposal.contract_type,
                                 uuid        : getUUID(),
                             },
                         })
-                    )
+                        .catch(e => {
+                            if (e.error.error.code === 'ContractBuyValidationError') {
+                                const { uuid } = e.error.echo_req.passthrough;
+
+                                if (!this.data.hasIn(['forgetProposals', uuid])) {
+                                    this.data = this.data.setIn(['proposals', uuid], {
+                                        ...proposal,
+                                        contractType: proposal.contract_type,
+                                        error       : e,
+                                    });
+                                }
+                            } else {
+                                this.$scope.observer.emit('Error', e);
+                            }
+                        })
                 )
-            ).catch(e => this.$scope.observer.emit('Error', e));
+            );
         }
         observeProposals() {
             this.listen('proposal', r => {
@@ -84,12 +102,15 @@ export default Engine =>
             return Promise.all(
                 proposals.map(proposal => {
                     const { uuid: id } = proposal;
+                    const removeProposal = uuid => {
+                        this.data = this.data.deleteIn(['forgetProposals', uuid]);
+                    };
 
-                    this.data = this.data.setIn(['forgetProposals', id], true);
-
-                    return doUntilDone(() => this.api.unsubscribeByID(proposal.id)).then(() => {
-                        this.data = this.data.deleteIn(['forgetProposals', id]);
-                    });
+                    if (proposal.error) {
+                        removeProposal(id);
+                        return Promise.resolve();
+                    }
+                    return doUntilDone(() => this.api.unsubscribeByID(proposal.id)).then(() => removeProposal(id));
                 })
             );
         }

src/botPage/bot/tools.js

@@ -5,32 +5,30 @@ import { notify } from './broadcast';
 
 export const noop = () => {};
 
-const castBarrierToString = barrier => (barrier > 0 ? `+${barrier}` : `${barrier}`);
-
 export const tradeOptionToProposal = tradeOption =>
-    tradeOption.contractTypes.map(type => ({
-        duration_unit: tradeOption.duration_unit,
-        basis        : 'stake',
-        currency     : tradeOption.currency,
-        symbol       : tradeOption.symbol,
-        duration     : tradeOption.duration,
-        amount       : roundBalance({ currency: tradeOption.currency, balance: tradeOption.amount }),
-        contract_type: type,
-        ...(tradeOption.prediction !== undefined && {
-            selected_tick: tradeOption.prediction,
-        }),
-        ...(type !== 'TICKLOW' &&
-            type !== 'TICKHIGH' &&
-            tradeOption.prediction !== undefined && {
-            barrier: tradeOption.prediction,
-        }),
-        ...(tradeOption.barrierOffset !== undefined && {
-            barrier: castBarrierToString(tradeOption.barrierOffset),
-        }),
-        ...(tradeOption.secondBarrierOffset !== undefined && {
-            barrier2: castBarrierToString(tradeOption.secondBarrierOffset),
-        }),
-    }));
+    tradeOption.contractTypes.map(type => {
+        const proposal = {
+            duration_unit: tradeOption.duration_unit,
+            basis        : 'stake',
+            currency     : tradeOption.currency,
+            symbol       : tradeOption.symbol,
+            duration     : tradeOption.duration,
+            amount       : roundBalance({ currency: tradeOption.currency, balance: tradeOption.amount }),
+            contract_type: type,
+        };
+        if (tradeOption.prediction !== undefined) {
+            proposal.selected_tick = tradeOption.prediction;
+        }
+        if (!['TICKLOW', 'TICKHIGH'].includes(type) && tradeOption.prediction !== undefined) {
+            proposal.barrier = tradeOption.prediction;
+        } else if (tradeOption.barrierOffset !== undefined) {
+            proposal.barrier = tradeOption.barrierOffset;
+        }
+        if (tradeOption.secondBarrierOffset !== undefined) {
+            proposal.barrier2 = tradeOption.secondBarrierOffset;
+        }
+        return proposal;
+    });
 
 export const getDirection = ticks => {
     const { length } = ticks;

src/botPage/common/const.js

@@ -142,7 +142,7 @@ const config = {
             },
         ],
     },
-    barrierTypes: [['+', '+'], ['-', '-']],
+    barrierTypes: [['Offset +', '+'], ['Offset -', '-']],
     ohlcFields  : [
         [translate('Open'), 'open'],
         [translate('High'), 'high'],
@@ -165,45 +165,8 @@ const config = {
         [translate('8 hours'), '28800'],
         [translate('1 day'), '86400'],
     ],
-    mainBlocks   : ['trade', 'before_purchase', 'after_purchase', 'during_purchase'],
-    durationTypes: {
-        RISEFALL: [
-            [translate('Ticks'), 't'],
-            [translate('Seconds'), 's'],
-            [translate('Minutes'), 'm'],
-            [translate('Hours'), 'h'],
-        ],
-        RISEFALLEQUALS: [
-            [translate('Ticks'), 't'],
-            [translate('Seconds'), 's'],
-            [translate('Minutes'), 'm'],
-            [translate('Hours'), 'h'],
-        ],
-        HIGHERLOWER: [
-            [translate('Ticks'), 't'],
-            [translate('Seconds'), 's'],
-            [translate('Minutes'), 'm'],
-            [translate('Hours'), 'h'],
-        ],
-        RESET: [
-            [translate('Ticks'), 't'],
-            [translate('Seconds'), 's'],
-            [translate('Minutes'), 'm'],
-            [translate('Hours'), 'h'],
-        ],
-        TOUCHNOTOUCH  : [[translate('Ticks'), 't'], [translate('Minutes'), 'm'], [translate('Hours'), 'h']],
-        ENDSINOUT     : [[translate('Minutes'), 'm'], [translate('Hours'), 'h']],
-        STAYSINOUT    : [[translate('Minutes'), 'm'], [translate('Hours'), 'h']],
-        ASIANS        : [[translate('Ticks'), 't']],
-        MATCHESDIFFERS: [[translate('Ticks'), 't']],
-        EVENODD       : [[translate('Ticks'), 't']],
-        OVERUNDER     : [[translate('Ticks'), 't']],
-        HIGHLOWTICKS  : [[translate('Ticks'), 't']],
-    },
-    hasPrediction         : ['MATCHESDIFFERS', 'OVERUNDER', 'HIGHLOWTICKS'],
-    hasBarrierOffset      : ['HIGHERLOWER', 'TOUCHNOTOUCH', 'ENDSINOUT', 'STAYSINOUT'],
-    hasSecondBarrierOffset: ['ENDSINOUT', 'STAYSINOUT'],
-    conditionsCategory    : {
+    mainBlocks        : ['trade', 'before_purchase', 'after_purchase', 'during_purchase'],
+    conditionsCategory: {
         callput     : ['risefall', 'higherlower'],
         callputequal: ['risefallequals'],
         touchnotouch: ['touchnotouch'],