From 8334709e3080f868a96b2565474cb5c91f7a94af Mon Sep 17 00:00:00 2001 From: Luis Fernando Molina Date: Wed, 12 Aug 2020 20:30:52 +0200 Subject: [PATCH] Code Tided --- LowFrequencyTrading/TradingOrders.js | 50 +++-- LowFrequencyTrading/TradingPosition.js | 62 ++++--- LowFrequencyTrading/TradingSimulation.js | 1 + LowFrequencyTrading/TradingStages.js | 227 +++++++++++------------ 4 files changed, 180 insertions(+), 160 deletions(-) diff --git a/LowFrequencyTrading/TradingOrders.js b/LowFrequencyTrading/TradingOrders.js index ca57a2380..d03b913ef 100644 --- a/LowFrequencyTrading/TradingOrders.js +++ b/LowFrequencyTrading/TradingOrders.js @@ -268,24 +268,42 @@ exports.newTradingOrders = function newTradingOrders(bot, logger, tradingEngineM if (tradingSystemOrder.config.percentageOfAlgorithmSize === undefined) { badDefinitionUnhandledException(undefined, 'tradingSystemOrder.config.percentageOfAlgorithmSize === undefined', tradingSystemOrder) } if (isNaN(tradingSystemOrder.config.percentageOfAlgorithmSize) === true) { badDefinitionUnhandledException(undefined, 'isNaN(tradingSystemOrder.config.percentageOfAlgorithmSize) === true', tradingSystemOrder) } - /* Size in Base Asset */ - tradingEngineOrder.orderBaseAsset.size.value = algorithmSizeInBaseAsset * tradingSystemOrder.config.percentageOfAlgorithmSize / 100 + /* + The Size calculation depends on how the user defined the size of the position. + The user could have defined the size of the position in Base Asset or Quoted Asset. + */ + switch (tradingEngineStage.stageDefinedIn.value) { + case 'Base Asset': { + /* Size in Base Asset */ + tradingEngineOrder.orderBaseAsset.size.value = algorithmSizeInBaseAsset * tradingSystemOrder.config.percentageOfAlgorithmSize / 100 - /* Size in Quoted Asset */ - tradingEngineOrder.orderQuotedAsset.size.value = algorithmSizeInQuotedAsset * tradingSystemOrder.config.percentageOfAlgorithmSize / 100 + /* Check that the Size calculated would not surpass Stage Target Size */ + if ( + tradingEngineOrder.orderBaseAsset.size.value + tradingEngineStage.stageBaseAsset.sizePlaced.value > + tradingEngineStage.stageBaseAsset.targetSize.value + ) { + tradingEngineOrder.orderBaseAsset.size.value = tradingEngineStage.stageBaseAsset.targetSize.value - tradingEngineStage.stageBaseAsset.sizePlaced.value + } - /* Check that the Size calculated would not surpass Stage Target Size */ - if ( - tradingEngineOrder.orderBaseAsset.size.value + tradingEngineStage.stageBaseAsset.sizePlaced.value > - tradingEngineStage.stageBaseAsset.targetSize.value - ) { - tradingEngineOrder.orderBaseAsset.size.value = tradingEngineStage.stageBaseAsset.targetSize.value - tradingEngineStage.stageBaseAsset.sizePlaced.value - } - if ( - tradingEngineOrder.orderQuotedAsset.size.value + tradingEngineStage.stageQuotedAsset.sizePlaced.value > - tradingEngineStage.stageQuotedAsset.targetSize.value - ) { - tradingEngineOrder.orderQuotedAsset.size.value = tradingEngineStage.stageQuotedAsset.targetSize.value - tradingEngineStage.stageQuotedAsset.sizePlaced.value + /* Size in Quoted Asset */ + tradingEngineOrder.orderQuotedAsset.size.value = tradingEngineOrder.orderBaseAsset.size.value * tradingEngineOrder.rate.value + break + } + case 'Quoted Asset': { + /* Size in Quoted Asset */ + tradingEngineOrder.orderQuotedAsset.size.value = algorithmSizeInQuotedAsset * tradingSystemOrder.config.percentageOfAlgorithmSize / 100 + + if ( + tradingEngineOrder.orderQuotedAsset.size.value + tradingEngineStage.stageQuotedAsset.sizePlaced.value > + tradingEngineStage.stageQuotedAsset.targetSize.value + ) { + tradingEngineOrder.orderQuotedAsset.size.value = tradingEngineStage.stageQuotedAsset.targetSize.value - tradingEngineStage.stageQuotedAsset.sizePlaced.value + } + + /* Size in Base Asset */ + tradingEngineOrder.orderBaseAsset.size.value = tradingEngineOrder.orderQuotedAsset.size.value / tradingEngineOrder.rate.value + break + } } tradingEngineOrder.orderBaseAsset.size.value = global.PRECISE(tradingEngineOrder.orderBaseAsset.size.value, 10) diff --git a/LowFrequencyTrading/TradingPosition.js b/LowFrequencyTrading/TradingPosition.js index 86016d7f4..43b85e7a5 100644 --- a/LowFrequencyTrading/TradingPosition.js +++ b/LowFrequencyTrading/TradingPosition.js @@ -112,37 +112,37 @@ exports.newTradingPosition = function newTradingPosition(bot, logger, tradingEng tradingEngine.current.position.takeProfit.takeProfitStage.value = stage } - function initialTargets(stageNode) { + function initialTargets(tradingSystemStageNode, tradingEngineStageNode) { - if (stageNode.initialTargets === undefined) { + if (tradingSystemStageNode.initialTargets === undefined) { const message = 'Stage without Initial Targets node. Add one please.' - badDefinitionUnhandledException(undefined, message, stageNode) + badDefinitionUnhandledException(undefined, message, tradingSystemStageNode) } setTargetRate() setTargetSize() function setTargetRate() { - if (stageNode.initialTargets.targetRate === undefined) { + if (tradingSystemStageNode.initialTargets.targetRate === undefined) { const message = 'Target Rate Node not Found. Fix this please.' - badDefinitionUnhandledException(undefined, message, stageNode.initialTargets) + badDefinitionUnhandledException(undefined, message, tradingSystemStageNode.initialTargets) } - if (stageNode.initialTargets.targetRate.formula === undefined) { + if (tradingSystemStageNode.initialTargets.targetRate.formula === undefined) { const message = 'Formula of Target Rate Node not Found. Fix this please.' - badDefinitionUnhandledException(undefined, message, stageNode.initialTargets.targetRate) + badDefinitionUnhandledException(undefined, message, tradingSystemStageNode.initialTargets.targetRate) } - let value = tradingSystem.formulas.get(stageNode.initialTargets.targetRate.formula.id) + let value = tradingSystem.formulas.get(tradingSystemStageNode.initialTargets.targetRate.formula.id) if (value === undefined) { const message = 'Target Rate can not be undefined. Fix this please.' - badDefinitionUnhandledException(undefined, message, stageNode.initialTargets.targetRate.formula) + badDefinitionUnhandledException(undefined, message, tradingSystemStageNode.initialTargets.targetRate.formula) } if (isNaN(value)) { const message = 'Target Rate must be a number. Fix this please.' - badDefinitionUnhandledException(undefined, message, stageNode.initialTargets.targetRate.formula) + badDefinitionUnhandledException(undefined, message, tradingSystemStageNode.initialTargets.targetRate.formula) } - switch (stageNode.type) { + switch (tradingSystemStageNode.type) { case 'Open Stage': { tradingEngine.current.position.entryTargetRate.value = global.PRECISE(value, 10) break @@ -157,27 +157,27 @@ exports.newTradingPosition = function newTradingPosition(bot, logger, tradingEng function setTargetSize() { /* Basic Validation */ if ( - stageNode.initialTargets.targetSizeInBaseAsset !== undefined && - stageNode.initialTargets.targetSizeInQuotedAsset !== undefined + tradingSystemStageNode.initialTargets.targetSizeInBaseAsset !== undefined && + tradingSystemStageNode.initialTargets.targetSizeInQuotedAsset !== undefined ) { const message = 'Only Target Size In Base Asset or Target Size In Quoted Asset is allowed. Remove one of them please.' - badDefinitionUnhandledException(undefined, message, stageNode) + badDefinitionUnhandledException(undefined, message, tradingSystemStageNode) } /* Position In Base Asset */ - if (stageNode.initialTargets.targetSizeInBaseAsset !== undefined) { - if (stageNode.initialTargets.targetSizeInBaseAsset.formula !== undefined) { - let value = tradingSystem.formulas.get(stageNode.initialTargets.targetSizeInBaseAsset.formula.id) + if (tradingSystemStageNode.initialTargets.targetSizeInBaseAsset !== undefined) { + if (tradingSystemStageNode.initialTargets.targetSizeInBaseAsset.formula !== undefined) { + let value = tradingSystem.formulas.get(tradingSystemStageNode.initialTargets.targetSizeInBaseAsset.formula.id) if (value === undefined) { const message = 'Target Size In Base Asset cannot be undefined. Fix this please.' - badDefinitionUnhandledException(undefined, message, stageNode.initialTargets.targetSizeInBaseAsset.formula) + badDefinitionUnhandledException(undefined, message, tradingSystemStageNode.initialTargets.targetSizeInBaseAsset.formula) } if (value === undefined) { const message = 'Target Size In Base Asset cannot be zero. Fix this please.' - badDefinitionUnhandledException(undefined, message, stageNode.initialTargets.targetSizeInBaseAsset.formula) + badDefinitionUnhandledException(undefined, message, tradingSystemStageNode.initialTargets.targetSizeInBaseAsset.formula) } - switch (stageNode.type) { + switch (tradingSystemStageNode.type) { case 'Open Stage': { tradingEngine.current.position.positionBaseAsset.entryTargetSize.value = global.PRECISE(value, 10) tradingEngine.current.position.positionQuotedAsset.entryTargetSize.value = @@ -191,25 +191,28 @@ exports.newTradingPosition = function newTradingPosition(bot, logger, tradingEng break } } + + /* Remember how the end user defined this stage. */ + tradingEngineStageNode.stageDefinedIn.value = 'Base Asset' } else { const message = 'You need to specify a Formula for this.' - badDefinitionUnhandledException(undefined, message, stageNode.initialTargets.targetSizeInBaseAsset) + badDefinitionUnhandledException(undefined, message, tradingSystemStageNode.initialTargets.targetSizeInBaseAsset) } } /* Position In Quoted Asset */ - if (stageNode.initialTargets.targetSizeInQuotedAsset !== undefined) { - if (stageNode.initialTargets.targetSizeInQuotedAsset.formula !== undefined) { - let value = tradingSystem.formulas.get(stageNode.initialTargets.targetSizeInQuotedAsset.formula.id) + if (tradingSystemStageNode.initialTargets.targetSizeInQuotedAsset !== undefined) { + if (tradingSystemStageNode.initialTargets.targetSizeInQuotedAsset.formula !== undefined) { + let value = tradingSystem.formulas.get(tradingSystemStageNode.initialTargets.targetSizeInQuotedAsset.formula.id) if (value === undefined) { const message = 'Target Size In Quoted Asset cannot be undefined. Fix this please.' - badDefinitionUnhandledException(undefined, message, stageNode.initialTargets.targetSizeInQuotedAsset.formula) + badDefinitionUnhandledException(undefined, message, tradingSystemStageNode.initialTargets.targetSizeInQuotedAsset.formula) } if (value === undefined) { const message = 'Target Size In Quoted Asset cannot be zero. Fix this please.' - badDefinitionUnhandledException(undefined, message, stageNode.initialTargets.targetSizeInQuotedAsset.formula) + badDefinitionUnhandledException(undefined, message, tradingSystemStageNode.initialTargets.targetSizeInQuotedAsset.formula) } - switch (stageNode.type) { + switch (tradingSystemStageNode.type) { case 'Open Stage': { tradingEngine.current.position.positionQuotedAsset.entryTargetSize.value = global.PRECISE(value, 10) tradingEngine.current.position.positionBaseAsset.entryTargetSize.value = @@ -223,9 +226,12 @@ exports.newTradingPosition = function newTradingPosition(bot, logger, tradingEng break } } + + /* Remember how the end user defined this stage. */ + tradingEngineStageNode.stageDefinedIn.value = 'Quoted Asset' } else { const errorText = 'You need to specify a Formula for this.' - badDefinitionUnhandledException(undefined, message, stageNode.initialTargets.targetSizeInQuotedAsset.formula) + badDefinitionUnhandledException(undefined, message, tradingSystemStageNode.initialTargets.targetSizeInQuotedAsset.formula) } } } diff --git a/LowFrequencyTrading/TradingSimulation.js b/LowFrequencyTrading/TradingSimulation.js index 6a8e98a75..46ab10021 100644 --- a/LowFrequencyTrading/TradingSimulation.js +++ b/LowFrequencyTrading/TradingSimulation.js @@ -197,6 +197,7 @@ exports.newTradingSimulation = function newTradingSimulation(bot, logger, UTILIT if (tradingEngine.current.episode.candle.index.value + 1 < candles.length) { + console.log('Processing Candle: ' + tradingEngine.current.episode.candle.index.value) /* Add new records to the process output */ tradingRecordsModule.appendRecords('Second') diff --git a/LowFrequencyTrading/TradingStages.js b/LowFrequencyTrading/TradingStages.js index e6735e3b9..a38245d34 100644 --- a/LowFrequencyTrading/TradingStages.js +++ b/LowFrequencyTrading/TradingStages.js @@ -273,27 +273,27 @@ exports.newTradingStages = function newTradingStages(bot, logger, tradingEngineM if (tradingEngine.current.strategyOpenStage.status.value === 'Opening') { /* This procedure is intended to run only once */ - let stageNode = tradingSystem.tradingStrategies[tradingEngine.current.strategy.index.value].openStage - let executionNode = stageNode.openExecution + let tradingSystemStage = tradingSystem.tradingStrategies[tradingEngine.current.strategy.index.value].openStage + let executionNode = tradingSystemStage.openExecution /* Reset the Exchange Orders data structure to its initial value */ tradingEngineModule.initializeNode(tradingEngine.exchangeOrders) - tradingSystem.evalConditions(stageNode, 'Initial Definition') - tradingSystem.evalFormulas(stageNode, 'Initial Definition') + tradingSystem.evalConditions(tradingSystemStage, 'Initial Definition') + tradingSystem.evalFormulas(tradingSystemStage, 'Initial Definition') /* Remember the balance we had before taking the position to later calculate profit or loss */ tradingEngine.current.position.positionBaseAsset.beginBalance = tradingEngine.current.episode.episodeBaseAsset.balance.value tradingEngine.current.position.positionQuotedAsset.beginBalance = tradingEngine.current.episode.episodeQuotedAsset.balance.value /* Entry Position size and rate */ - tradingSystem.evalFormulas(stageNode, 'Initial Targets') - tradingPositionModule.initialTargets(stageNode) + tradingSystem.evalFormulas(tradingSystemStage, 'Initial Targets') + tradingPositionModule.initialTargets(tradingSystemStage, tradingEngine.current.strategyOpenStage) initializeStageTargetSize() /* Check Execution at open stage node */ - tradingSystem.evalConditions(stageNode, 'Open Execution') - tradingSystem.evalFormulas(stageNode, 'Open Execution') + tradingSystem.evalConditions(tradingSystemStage, 'Open Execution') + tradingSystem.evalFormulas(tradingSystemStage, 'Open Execution') await tradingExecutionModule.runExecution( executionNode, @@ -311,55 +311,18 @@ exports.newTradingStages = function newTradingStages(bot, logger, tradingEngineM While the Open Stage is Open, we do our regular stuff: place orders and check what happened to the orders already placed. */ - let stageNode = tradingSystem.tradingStrategies[tradingEngine.current.strategy.index.value].openStage - let executionNode = stageNode.openExecution + let tradingSystemStage = tradingSystem.tradingStrategies[tradingEngine.current.strategy.index.value].openStage + let executionNode = tradingSystemStage.openExecution /* Every Loop Cycle Activity */ - tradingSystem.evalConditions(stageNode, 'Open Execution') - tradingSystem.evalFormulas(stageNode, 'Open Execution') + tradingSystem.evalConditions(tradingSystemStage, 'Open Execution') + tradingSystem.evalFormulas(tradingSystemStage, 'Open Execution') await tradingExecutionModule.runExecution( executionNode, tradingEngine.current.strategyOpenStage ) - /* - The Open is finished when the placedSize reaches the targetSize in any of the - stage assets, and the fillSize + feesPaid reaches the placedSize also in any - of the stage Assets. - This can happens at any time when we update the sizeFilled and the feesPaid values - when we see at the exchange that orders were filled. - */ - if ( - ( - tradingEngine.current.strategyOpenStage.stageBaseAsset.sizePlaced >= - tradingEngine.current.strategyOpenStage.stageBaseAsset.targetSize - - || - - tradingEngine.current.strategyOpenStage.stageQuotedAsset.sizePlaced >= - tradingEngine.current.strategyOpenStage.stageQuotedAsset.targetSize - ) - && - ( - tradingEngine.current.strategyOpenStage.stageBaseAsset.sizeFilled.value + - tradingEngine.current.strategyOpenStage.stageBaseAsset.feesPaid.value >= - tradingEngine.current.strategyOpenStage.stageBaseAsset.sizePlaced.value - - || - - tradingEngine.current.strategyOpenStage.stageQuotedAsset.sizeFilled.value + - tradingEngine.current.strategyOpenStage.stageQuotedAsset.feesPaid.value >= - tradingEngine.current.strategyOpenStage.stageQuotedAsset.sizePlaced.value - ) - ) { - changeStageStatus('Open Stage', 'Closed', 'Position Size Filled') - } else { - /* Check the Close Stage Event */ - tradingSystem.evalConditions(stageNode, 'Close Stage Event') - if (checkStopStageEvent(stageNode) === true) { - changeStageStatus('Open Stage', 'Closing', 'Close Stage Event') - } - } + checkIfStageNeedsToBeClosed(tradingEngine.current.strategyOpenStage, tradingSystemStage, 'Open Stage') } /* Closing Status Procedure */ @@ -368,15 +331,15 @@ exports.newTradingStages = function newTradingStages(bot, logger, tradingEngineM During the closing stage status, we do not place new orders, just check if the ones placed were filled, and cancel the ones not filled. */ - let stageNode = tradingSystem.tradingStrategies[tradingEngine.current.strategy.index.value].openStage - let executionNode = stageNode.openExecution + let tradingSystemStage = tradingSystem.tradingStrategies[tradingEngine.current.strategy.index.value].openStage + let executionNode = tradingSystemStage.openExecution /* Check if there are unfilled orders, we will check if they were executed, and cancel the ones that were not. */ - tradingSystem.evalConditions(stageNode, 'Open Execution') - tradingSystem.evalFormulas(stageNode, 'Open Execution') + tradingSystem.evalConditions(tradingSystemStage, 'Open Execution') + tradingSystem.evalFormulas(tradingSystemStage, 'Open Execution') await tradingExecutionModule.runExecution( executionNode, @@ -384,24 +347,33 @@ exports.newTradingStages = function newTradingStages(bot, logger, tradingEngineM ) /* - The Closing is finished when the fillSize + feesPaid reaches the ordersSize. + The Closing is finished when the sizeFilled + feesPaid reaches the sizePlaced. This can happens either because we update the sizeFilled value when we see - at the exchange that orders were filled, or we reduce the ordersSize when + at the exchange that orders were filled, or we reduce the sizePlaced when we cancel not yet filled orders. Here it does not matter the targetSize since this status represent a force closure of this stage. */ - if ( - tradingEngine.current.strategyOpenStage.stageBaseAsset.sizeFilled.value + - tradingEngine.current.strategyOpenStage.stageBaseAsset.feesPaid.value >= - tradingEngine.current.strategyOpenStage.stageBaseAsset.sizePlaced.value - - || - - tradingEngine.current.strategyOpenStage.stageQuotedAsset.sizeFilled.value + - tradingEngine.current.strategyOpenStage.stageQuotedAsset.feesPaid.value >= - tradingEngine.current.strategyOpenStage.stageQuotedAsset.sizePlaced.value - ) { - changeStageStatus('Open Stage', 'Closed') + switch (tradingEngine.current.strategyOpenStage.stageDefinedIn.value) { + case 'Base Asset': { + if ( + tradingEngine.current.strategyOpenStage.stageBaseAsset.sizeFilled.value + + tradingEngine.current.strategyOpenStage.stageBaseAsset.feesPaid.value >= + tradingEngine.current.strategyOpenStage.stageBaseAsset.sizePlaced.value + ) { + changeStageStatus('Open Stage', 'Closed') + } + break + } + case 'Quoted Asset': { + if ( + tradingEngine.current.strategyOpenStage.stageQuotedAsset.sizeFilled.value + + tradingEngine.current.strategyOpenStage.stageQuotedAsset.feesPaid.value >= + tradingEngine.current.strategyOpenStage.stageQuotedAsset.sizePlaced.value + ) { + changeStageStatus('Open Stage', 'Closed') + } + break + } } } @@ -435,9 +407,9 @@ exports.newTradingStages = function newTradingStages(bot, logger, tradingEngineM if ( tradingEngine.current.position.stopLoss.stopLossStage.value === 'Open Stage' || tradingEngine.current.position.takeProfit.takeProfitStage.value === 'Open Stage') { - let stageNode = tradingSystem.tradingStrategies[tradingEngine.current.strategy.index.value].openStage - tradingSystem.evalConditions(stageNode, 'Initial Definition') - tradingSystem.evalFormulas(stageNode, 'Initial Definition') + let tradingSystemStage = tradingSystem.tradingStrategies[tradingEngine.current.strategy.index.value].openStage + tradingSystem.evalConditions(tradingSystemStage, 'Initial Definition') + tradingSystem.evalFormulas(tradingSystemStage, 'Initial Definition') } /* Stop Loss Management */ @@ -825,11 +797,11 @@ exports.newTradingStages = function newTradingStages(bot, logger, tradingEngineM the total filled size of the Open Stage. By skiping execution now we allow the open stage to get a final value for sizeFilled that we can use. */ - let stageNode = tradingSystem.tradingStrategies[tradingEngine.current.strategy.index.value].closeStage + let tradingSystemStage = tradingSystem.tradingStrategies[tradingEngine.current.strategy.index.value].closeStage /* Exit Position size and rate */ - tradingSystem.evalFormulas(stageNode, 'Initial Targets') - tradingPositionModule.initialTargets(stageNode) + tradingSystem.evalFormulas(tradingSystemStage, 'Initial Targets') + tradingPositionModule.initialTargets(tradingSystemStage, tradingEngine.current.strategyCloseStage) initializeStageTargetSize() changeStageStatus('Close Stage', 'Open') @@ -841,55 +813,18 @@ exports.newTradingStages = function newTradingStages(bot, logger, tradingEngineM /* This will happen as long as the Close Stage is Open. */ - let stageNode = tradingSystem.tradingStrategies[tradingEngine.current.strategy.index.value].closeStage - let executionNode = stageNode.closeExecution + let tradingSystemStage = tradingSystem.tradingStrategies[tradingEngine.current.strategy.index.value].closeStage + let executionNode = tradingSystemStage.closeExecution - tradingSystem.evalConditions(stageNode, 'Close Execution') - tradingSystem.evalFormulas(stageNode, 'Close Execution') + tradingSystem.evalConditions(tradingSystemStage, 'Close Execution') + tradingSystem.evalFormulas(tradingSystemStage, 'Close Execution') await tradingExecutionModule.runExecution( executionNode, tradingEngine.current.strategyCloseStage ) - /* - The Open is finished when the placedSize reaches the targetSize in any of the - stage assets, and the fillSize + feesPaid reaches the placedSize also in any - of the stage Assets. - This can happens at any time when we update the sizeFilled and the feesPaid values - when we see at the exchange that orders were filled. - */ - if ( - ( - tradingEngine.current.strategyCloseStage.stageBaseAsset.sizePlaced >= - tradingEngine.current.strategyCloseStage.stageBaseAsset.targetSize - - || - - tradingEngine.current.strategyCloseStage.stageQuotedAsset.sizePlaced >= - tradingEngine.current.strategyCloseStage.stageQuotedAsset.targetSize - ) - && - ( - tradingEngine.current.strategyCloseStage.stageBaseAsset.sizeFilled.value + - tradingEngine.current.strategyCloseStage.stageBaseAsset.feesPaid.value >= - tradingEngine.current.strategyCloseStage.stageBaseAsset.sizePlaced.value - - || - - tradingEngine.current.strategyCloseStage.stageQuotedAsset.sizeFilled.value + - tradingEngine.current.strategyCloseStage.stageQuotedAsset.feesPaid.value >= - tradingEngine.current.strategyCloseStage.stageQuotedAsset.sizePlaced.value - ) - ) { - changeStageStatus('Close Stage', 'Closed', 'Size Placed Filled') - } else { - /* Check the Close Stage Event */ - tradingSystem.evalConditions(stageNode, 'Close Stage Event') - if (checkStopStageEvent(stageNode) === true) { - changeStageStatus('Close Stage', 'Closing', 'Close Stage Event') - } - } + checkIfStageNeedsToBeClosed(tradingEngine.current.strategyCloseStage, tradingSystemStage, 'Close Stage') } /* Exit Position Validation */ @@ -965,6 +900,66 @@ exports.newTradingStages = function newTradingStages(bot, logger, tradingEngineM } } + function checkIfStageNeedsToBeClosed(tradingEngineStage, tradingSystemStage, stageName) { + /* + The Stage is closed when the placedSize reaches the targetSize, and the fillSize + + feesPaid reaches the placedSize. This depends on how the user defined the stage: + either on Base Asset or Quoted Asset. + This can happens at any time when we update the sizeFilled and the feesPaid values + when we see at the exchange that orders were filled. + */ + switch (tradingEngineStage.stageDefinedIn.value) { + case 'Base Asset': { + if ( + ( + tradingEngineStage.stageBaseAsset.sizePlaced >= + tradingEngineStage.stageBaseAsset.targetSize + ) + && + ( + tradingEngineStage.stageBaseAsset.sizeFilled.value + + tradingEngineStage.stageBaseAsset.feesPaid.value >= + tradingEngineStage.stageBaseAsset.sizePlaced.value + ) + ) { + positionFilled() + } else { + checkCloseStageEvent() + } + break + } + case 'Quoted Asset': { + if ( + ( + tradingEngineStage.stageQuotedAsset.sizePlaced >= + tradingEngineStage.stageQuotedAsset.targetSize + ) + && + ( + tradingEngineStage.stageQuotedAsset.sizeFilled.value + + tradingEngineStage.stageQuotedAsset.feesPaid.value >= + tradingEngineStage.stageQuotedAsset.sizePlaced.value + ) + ) { + positionFilled() + } else { + checkCloseStageEvent() + } + break + } + } + function positionFilled() { + changeStageStatus(stageName, 'Closed', 'Position Size Filled') + } + function checkCloseStageEvent() { + /* Check the Close Stage Event */ + tradingSystem.evalConditions(tradingSystemStage, 'Close Stage Event') + if (checkStopStageEvent(tradingSystemStage) === true) { + changeStageStatus(stageName, 'Closing', 'Close Stage Event') + } + } + } + function checkStopStageEvent(stage) { /* Check the Close Stage Event. */