Code Tided

This commit is contained in:
Luis Fernando Molina committed 2020-08-12 20:30:52 +02:00
1 parent 3d351bfb86
commit 8334709e30
4 files changed
+180 -160

No files matched your search

+34 -16
View File
@@ -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)
+34 -28
View File
@@ -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)
}
}
}
+1
View File
@@ -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')
+111 -116
View File
@@ -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. */