Trading Events Flow example

IOC order filling


IOC order full fill

Given When (client request) Then (server response) Then (open API response)
newOrder{MKT buy 2M} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 2M ExecutionEvent{OrderFilled} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=2M, snapshot of position is present}

IOC order full fill with several deals (Quotix version)

Given When (client request) Then (server response) Then (open API response)
newOrder{MKT buy 2M} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 0.5M ExecutionEvent{OrderPartialFill, order.executedVolume=0.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=0.5M, snapshot of position is present}
fill 1.5M ExecutionEvent{OrderFilled, order.executedVolume=2M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=2M, snapshot of position is present}

IOC order partial fill

Given When (client request) Then (server response) Then (open API response)
newOrder{MKT buy 2M} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 0.5M ExecutionEvent{OrderCancelled, order.executedVolume=0.5M} ExecutionEvent{OrderCancelled, order.tradeData.volume=2M, order.executedVolume=0.5M, reasonCode, snapshot of position is present}

IOC order partial fill with several deals (Quotix version)

Given When (client request) Then (server response) Then (open API response)
newOrder{MKT buy 2M} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 0.5M ExecutionEvent{OrderPartialFill, order.executedVolume=0.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=0.5M, snapshot of position is present}
fill 1M ExecutionEvent{OrderCancelled, order.executedVolume=1.5M} ExecutionEvent{OrderCancelled, order.tradeData.volume=2M, order.executedVolume=1.5M, reasonCode, snapshot of position is present}

IOC order not filled (cancelled)

Given When (client request) Then (server response) Then (open API response)
newOrder{MKT buy 2M} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
nothing filled ExecutionEvent{OrderCancelled, order.executedVolume=0} ExecutionEvent{OrderCancelled, reasonCode, position is absent}

GTD order filling


GTD order full fill

Given When (client request) Then (server response) Then (open API response)
newOrder{MKT buy 2M} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 2M ExecutionEvent{OrderFilled} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=2M, snapshot of position is present}

GTD order full fill with several deals

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345 GTD=15min} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 0.5M ExecutionEvent{OrderPartialFill, order.executedVolume=0.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=0.5M, snapshot of position is present}
fill 1.5M ExecutionEvent{OrderFilled, order.executedVolume=2M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=2M, snapshot of position is present}

GTD order partial fill

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345 GTD=15min} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 0.5M ExecutionEvent{OrderPartialFill, order.executedVolume=0.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=0.5M, snapshot of position is present}
expire ExecutionEvent{OrderExpired, order.executedVolume=0.5M} ExecutionEvent{OrderExpired, snapshot of position is present}

GTD order partial fill with several deals

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345 GTD=15min} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 0.5M ExecutionEvent{OrderPartialFill, order.executedVolume=0.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=0.5M, snapshot of position is present}
fill 1M ExecutionEvent{OrderPartialFill, order.executedVolume=1.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=1.5M, snapshot of position is present}
expire ExecutionEvent{OrderExpired, order.executedVolume=1.5M} ExecutionEvent{OrderExpired, snapshot of position is present}

GTD order not filled (expired)

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345 GTD=15min} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
expire ExecutionEvent{OrderExpired, order.executedVolume=0} ExecutionEvent{OrderExpired, position is absent}

GTC order filling


GTC order full fill

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 2M ExecutionEvent{OrderFilled} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=2M, snapshot of position is present}

GTC order full fill with several deals

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 0.5M ExecutionEvent{OrderPartialFill, order.executedVolume=0.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=0.5M, snapshot of position is present}
fill 1.5M ExecutionEvent{OrderFilled, order.executedVolume=2M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=2M, snapshot of position is present}

GTC order partial fill and cancel by client

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 0.5M ExecutionEvent{OrderPartialFill, order.executedVolume=0.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=0.5M, snapshot of position is present}
cancelOrder ExecutionEvent{OrderCancelled, order.executedVolume=0.5M} ExecutionEvent{OrderCancelled, reasonCode, snapshot of position is present}

GTC order partial fill with several deals and cancel by client

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 0.5M ExecutionEvent{OrderPartialFill, order.executedVolume=0.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=0.5M, snapshot of position is present}
fill 1M ExecutionEvent{OrderPartialFill, order.executedVolume=1.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=1.5M, snapshot of position is present}
cancelOrder ExecutionEvent{OrderCancelled, order.executedVolume=1.5M} ExecutionEvent{OrderCancelled, reasonCode, snapshot of position is present}

GTC order cancelled by client

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
cancelOrder ExecutionEvent{OrderCancelled, order.executedVolume=0} ExecutionEvent{OrderCancelled, reasonCode, position is absent}

Cancel (by trader) order


CancelOrder command is avaliable only for GTD and GTC orders in Accepted state

Not filled order

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
cancelOrder ExecutionEvent{OrderCancelled} ExecutionEvent{OrderCancelled, reasonCode, position is absent}

Partially filled order

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 0.5M ExecutionEvent{OrderPartialFill, order.executedVolume=0.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=0.5M, snapshot of position is present}
cancelOrder ExecutionEvent{OrderCancelled, order.executedVolume=0.5M} ExecutionEvent{OrderCancelled, reasonCode, snapshot of position is present}

Amend order


AmendOrder command is avaliable only for GTD and GTC orders in Accepted state

Not filled order

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
amendOrder{limitPrice=1.2346} ExecutionEvent{OrderReplaced, order.limitPrice=1.2346} ExecutionEvent{OrderAmended, order.limitPrice=1.2346, position is absent}

Partially filled order

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
fill 0.5M ExecutionEvent{OrderPartialFill, order.executedVolume=0.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=0.5M, snapshot of position is present}
amendOrder{limitPrice=1.2346} ExecutionEvent{OrderReplaced, order.limitPrice=1.2346} ExecutionEvent{OrderAmended, order.limitPrice=1.2346, snapshot of position is present}

Change TIF GTC to GTD

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, position is absent}
amendOrder{GTD=15min} ExecutionEvent{OrderReplaced, order.expirationTimestamp=15min} ExecutionEvent{OrderAmended, order.expirationTimestamp=15min, position is absent}

Change TIF GTD to GTC

Given When (client request) Then (server response) Then (open API response)
newOrder{LMT buy 2M at 1.2345, GTD=15min} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, order.expirationTimestamp=15min, position is absent}
amendOrder{GTD=null} ExecutionEvent{OrderReplaced, order.expirationTimestamp=null} ExecutionEvent{OrderAmended, order.expirationTimestamp=null, position is absent}

Close position


ClosePosition command is avaliable only for open position

Full close position

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345 closePosition{2M} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, snapshot of position is present}
fill 2M at 1.2335 ExecutionEvent{OrderFilled, order.executedVolume=2M} ExecutionEvent{OrderFilled, order.tradeData.volume=2M, order.executedVolume=2M, snapshot of position is present}

Partial close position

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345 closePosition{0.5M} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=0.5M, order.executedVolume=0, snapshot of position is present}
fill 0.5M at 1.2335 ExecutionEvent{OrderFilled, order.executedVolume=0.5M} ExecutionEvent{OrderFilled, order.tradeData.volume=0.5M, order.executedVolume=0.5M, snapshot of position is present}

Full close position with partial fill

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345 closePosition{2M} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=2M, order.executedVolume=0, snapshot of position is present}
fill 0.5M at 1.2335 ExecutionEvent{OrderCancelled, order.executedVolume=0.5M} ExecutionEvent{OrderCancelled, order.tradeData.volume=0.5M, order.executedVolume=0.5M, reasonCode, snapshot of position is present}

Partial close position with partial fill

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345 closePosition{1M} ExecutionEvent{OrderAccepted} ExecutionEvent{OrderAccepted, order.tradeData.volume=1M, order.executedVolume=0, snapshot of position is present}
fill 0.5M at 1.2335 ExecutionEvent{OrderCancelled, order.executedVolume=0.5M} ExecutionEvent{OrderCancelled, order.tradeData.volume=1M, order.executedVolume=0.5M, reasonCode, snapshot of position is present}

Full close protected position

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345 with takeProfit=1.2355 closePosition{2M} ExecutionEvent{OrderAccepted, orderId=ID1} ExecutionEvent{OrderAccepted, orderId=ID1, order.tradeData.volume=2M, order.executedVolume=0, snapshot of position is present}
cancel protection order ExecutionEvent{OrderCancelled, orderId=ID2, order.closingOrder=true, position.takeProfit=null} ExecutionEvent{OrderCancelled, orderId=ID2, order.type=PROTECTION, position.takeProfit=null, reasonCode, snapshot of position is present}
fill 2M at 1.2335 ExecutionEvent{OrderFilled, orderId=ID1, order.executedVolume=2M} ExecutionEvent{OrderFilled, orderId=ID1, order.tradeData.volume=2M, order.executedVolume=2M, snapshot of position is present}

Partial close protected position

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345 with takeProfit=1.2355 closePosition{0.5M} ExecutionEvent{OrderAccepted, orderId=ID1} ExecutionEvent{OrderAccepted, orderId=ID1, order.tradeData.volume=0.5M, order.executedVolume=0, snapshot of position is present}
cancel protection order ExecutionEvent{OrderCancelled, orderId=ID2, order.closingOrder=true, position.takeProfit=null} ExecutionEvent{OrderCancelled, orderId=ID2, order.type=PROTECTION, position.takeProfit=null, reasonCode, snapshot of position is present}
fill 0.5M at 1.2335 ExecutionEvent{OrderFilled, orderId=ID1, order.executedVolume=0.5M} ExecutionEvent{OrderFilled, orderId=ID1, order.tradeData.volume=0.5M, order.executedVolume=0.5M, snapshot of position is present}
ExecutionEvent{OrderAccepted, orderId=ID3, order.tradeData.volume=1.5M, order.executedVolume=0, order.closingOrder=true, position.takeProfit=1.2355} ExecutionEvent{OrderAccepted, orderId=ID3, order.type=PROTECTION, order.tradeData.volume=1.5M, order.executedVolume=0, snapshot of position is present}

Full close protected position with partial fill

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345 with takeProfit=1.2355 closePosition{2M} ExecutionEvent{OrderAccepted, orderId=ID1} ExecutionEvent{OrderAccepted, orderId=ID1, order.tradeData.volume=2M, order.executedVolume=0, snapshot of position is present}
cancel protection order ExecutionEvent{OrderCancelled, orderId=ID2, order.closingOrder=true, position.takeProfit=null} ExecutionEvent{OrderCancelled, orderId=ID2, order.type=PROTECTION, position.takeProfit=null, reasonCode, snapshot of position is present}
fill 0.5M at 1.2335 ExecutionEvent{OrderCancelled, orderId=ID1, order.executedVolume=0.5M} ExecutionEvent{OrderCancelled, orderId=ID1, order.tradeData.volume=2M, order.executedVolume=0.5M, reasonCode, snapshot of position is present}
ExecutionEvent{OrderAccepted, orderId=ID3, order.tradeData.volume=1.5M, order.executedVolume=0, order.closingOrder=true, position.takeProfit=1.2355} ExecutionEvent{OrderAccepted, orderId=ID3, order.type=PROTECTION, order.tradeData.volume=1.5M, order.executedVolume=0, snapshot of position is present}

Partial close protected position with partial fill

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345 with takeProfit=1.2355 closePosition{1M} ExecutionEvent{OrderAccepted, orderId=ID1} ExecutionEvent{OrderAccepted, orderId=ID1, order.tradeData.volume=1M, order.executedVolume=0, snapshot of position is present}
cancel protection order ExecutionEvent{OrderCancelled, orderId=ID2, order.closingOrder=true, position.takeProfit=null} ExecutionEvent{OrderCancelled, orderId=ID2, order.type=PROTECTION, position.takeProfit=null, reasonCode, snapshot of position is present}
fill 0.5M at 1.2335 ExecutionEvent{OrderCancelled, orderId=ID1, order.executedVolume=0.5M} ExecutionEvent{OrderCancelled, orderId=ID1, order.tradeData.volume=1M, order.executedVolume=0.5M, reasonCode, snapshot of position is present}
ExecutionEvent{OrderAccepted, orderId=ID3, order.tradeData.volume=1.5M, order.executedVolume=0, order.closingOrder=true, position.takeProfit=1.2355} ExecutionEvent{OrderAccepted, orderId=ID3, order.type=PROTECTION, order.tradeData.volume=1.5M, order.executedVolume=0, snapshot of position is present}

Close position by protection full fill

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345 with stopLoss=1.2335
fill 2M at 1.2335 ExecutionEvent{OrderFilled, order.executedVolume=2M, order.closingOrder=true} ExecutionEvent{OrderFilled, order.type=PROTECTION, order.tradeData.volume=2M, order.executedVolume=2M, snapshot of position is present}

Close position by protection fill close with partial fills

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345 with stopLoss=1.2335
fill 0.5M at 1.2335 ExecutionEvent{OrderPartialFill, order.executedVolume=0.5M, order.closingOrder=true} ExecutionEvent{OrderFilled, order.type=PROTECTION, order.tradeData.volume=2M, order.executedVolume=0.5M, snapshot of position is present}
fill 1.5M at 1.2335 ExecutionEvent{OrderFilled, order.executedVolume=2M, order.closingOrder=true} ExecutionEvent{OrderFilled, order.type=PROTECTION, order.tradeData.volume=2M, order.executedVolume=2M, snapshot of position is present}

Amend position protection


AmendPositionStopLossTakeProfit command is avaliable only for open position

Note: ExecutionEvent of OrderReplaced type market with asterisk (*) is fake events inherited from text protocol. It contians open order for the position. Clients should process position from event only or ignore whole event.

Set stop loss for not protected position

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345
AmendPositionStopLossTakeProfit {stopLoss=1.2335} ExecutionEvent*{OrderReplaced, position.stopLoss=1.2335} any OrderReplaced message can be ignored if order.orderStatus != ORDER_STATUS_ACCEPTED
ExecutionEvent{OrderAccepted, order.type=STOP, order.closingOrder=true, order.stopPrice=1.2335, position.stopLoss=1.2335} ExecutionEvent{OrderAccepted, order.type=PROTECTION, order.type=PROTECTION, order.stopPrice=1.2335, position.stopLoss=1.2335, snapshot of position is present}

Set take profit for not protected position

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345
AmendPositionStopLossTakeProfit {takeProfit=1.2365} ExecutionEvent*{OrderReplaced, position.takeProfit=1.2365} any OrderReplaced message can be ignored if order.orderStatus != ORDER_STATUS_ACCEPTED
ExecutionEvent{OrderAccepted, order.type=LIMIT, order.closingOrder=true, order.limitPrice=1.2365, position.takeProfit=1.2365} ExecutionEvent{OrderAccepted, order.type=PROTECTION, order.limitPrice=1.2365, position.takeProfit=1.2365, snapshot of position is present}

Set stop loss and take profit for not protected position

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345
AmendPositionStopLossTakeProfit {stopLoss=1.2335, takeProfit=1.2365} ExecutionEvent*{OrderReplaced, position.stopLoss=1.2335, position.takeProfit=1.2365} any OrderReplaced message can be ignored if order.orderStatus != ORDER_STATUS_ACCEPTED
ExecutionEvent{OrderAccepted, order.type=STOP_LOSS_TAKE_PROFIT, order.closingOrder=true, order.stopPrice=1.2335, order.limitPrice=1.2365, position.stopLoss=1.2335, position.takeProfit=1.2365} ExecutionEvent{OrderAccepted, order.type=PROTECTION, order.stopPrice=1.2335, order.limitPrice=1.2365, position.stopLoss=1.2335, position.takeProfit=1.2365, snapshot of position is present}

Amend protection for a position with the same type

valid for cases

Old protection Protection order type New protection
stopLoss=1.2335, takeProfit=null order.type=STOP stopLoss=1.2330, takeProfit=null
stopLoss=null, takeProfit=1.2365 order.type=LIMIT stopLoss=null, takeProfit=1.2360
stopLoss=1.2335, takeProfit=1.2365 order.type=STOP_LOSS_TAKE_PROFIT stopLoss=1.2330, takeProfit=1.2360

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345 with stopLoss=X, takeProfit=Y
AmendPositionStopLossTakeProfit {stopLoss=X1, takeProfit=Y1} ExecutionEvent*{OrderReplaced, position.stopLoss=X1, position.takeProfit=Y1} any OrderReplaced message can be ignored if order.orderStatus != ORDER_STATUS_ACCEPTED
ExecutionEvent{OrderReplaced, order.type=, order.closingOrder=true, order.stopPrice=X1, position.stopLoss=Y1} ExecutionEvent{OrderAccepted, order.type=PROTECTION, order.stopPrice=X1, position.stopLoss=Y1, snapshot of position is present}

Amend protection to other type for a position

occurs when protection order type should be changed

Given When (client request) Then (server response) Then (open API response)
open position buy 2M at 1.2345 with stopLoss=null, takeProfit=1.2365
AmendPositionStopLossTakeProfit {stopLoss=1.2335} ExecutionEvent*{OrderReplaced, position.stopLoss=1.2335, position.takeProfit=null} any OrderReplaced message can be ignored if order.orderStatus != ORDER_STATUS_ACCEPTED
cancels current protection ExecutionEvent{OrderCancelled, order.type=LIMIT, order.closingOrder=true, order.limitPrice=1.2365, position.stopLoss=null, position.takeProfit=null} ExecutionEvent{OrderCancelled, order.type=PROTECTION, reasonCode, snapshot of position is present}
ExecutionEvent{OrderAccepted, order.type=STOP, order.closingOrder=true, order.stopPrice=1.2335, position.stopLoss=1.2335} ExecutionEvent{OrderAccepted, order.type=PROTECTION, order.stopPrice=1.2335, position.stopLoss=1.2335, snapshot of position is present}