Add short handling logic

Author: Fernando Fernandes

Sources/SwiftTrader/Model/Error/SwiftTraderError.swift

@@ -48,8 +48,11 @@ public enum SwiftTraderError: Error {
     /// The offsett has to be lower than the percentage of the profit; the order will not be placed.
     case kucoinInvalidOffset(offset: Double, profitPercentage: Double)
 
-    /// The target price is lower than the entry price; the order will not be placed.
-    case kucoinInvalidTargetPrice(entryPrice: String, targetPrice: String)
+    /// (`long` position) The target price is lower than the entry price; the order will not be placed.
+    case kucoinInvalidTargetPriceLower(entryPrice: String, targetPrice: String)
+    
+    /// (`short` position) The target price is higher than the entry price; the order will not be placed.
+    case kucoinInvalidTargetPriceHigher(entryPrice: String, targetPrice: String)
 
     /// And error ocurred while executing the function `SwiftTrader.kucoinFuturesOrderList(orderStatus:)`.
     case kucoinOrderList(error: Error)

Sources/SwiftTrader/Model/SwiftTraderOrderInput.swift

@@ -12,52 +12,58 @@ public struct SwiftTraderStopLimitOrderInput {
 
     // MARK: - Properties
 
+    public let clean: Bool
+    public let contractSymbol: String
+    public let currentPrice: Double
+    public let entryPrice: Double
     public let exchange: SwiftTraderExchange
+    public let isLong: Bool
     public let ticker: String
     public let tickerSize: String
-    public let contractSymbol: String
-    public let entryPrice: Double
-    public let currentPrice: Double
-    public let profitPercentage: Double
     public let offset: Double
-    public let clean: Bool
+    public let profitPercentage: Double
 
     // MARK: - Lifecycle
 
     /// Creates a `SwiftTraderOrderInput` instance.
     ///
     /// - Parameters:
+    ///   - clean: When `true`, all the untriggered stop orders for the `contractSymbol` will be cancelled before placing a new one.
+    ///   Cleaning is done via `SwiftTrader.kucoinFuturesCancelStopOrders(symbol:)`. In case that fails, the execution continues
+    ///   and a new order will be placed regardless.
+    ///   - contractSymbol: E.g.: XBTCUSDTM
+    ///   - currentPrice: The current price of the asset.
+    ///   - entryPrice: E.g.: "42.856", "43567.98", "127.01".
     ///   - exchange: E.g.: Kucoin, Binance
+    ///   - isLong: Indicates the side of the position. `true` indicates "long". `false` indicates "short. The side is taken into consideration
+    ///   when performing trailing stop logic.
     ///   - ticker: E.g.: BTCUSDT
     ///   - tickerSize: E.g.: "1", "0.05", "0.00001"
-    ///   - contractSymbol: E.g.: XBTCUSDTM
-    ///   - entryPrice: E.g.: "42.856", "43567.98", "127.01".
-    ///   - currentPrice: The current price of the asset.
-    ///   - profitPercentage: The percentage of the profit at this point, e.g.: "1.5", "0.67".
     ///   - offset: How far the **"target price"** of the stop order will be from the `currentPrice`. For example,
     ///   suppose the `profitPercentage` is `1.0%` and the `offset` is `0.75%`. The stop order to be placed will be `0.25%`
     ///   of the current price (`1.0%` - `0.75%`). Using the same `offset`, if the `profitPercentage` is now `2.0%`, the stop order
     ///   will be placed at `1.25%` of the current price (`2.0%` - `0.75%`).
-    ///   - clean: When `true`, all the untriggered stop orders for the `contractSymbol` will be cancelled before placing a new one.
-    ///   Cleaning is done via `SwiftTrader.kucoinFuturesCancelStopOrders(symbol:)`. In case that fails, the execution continues
-    ///   and a new order will be placed regardless.
-    public init(exchange: SwiftTraderExchange,
-                ticker: String,
-                tickerSize: String,
+    ///   - profitPercentage: The percentage of the profit at this point, e.g.: "1.5", "0.67".
+    public init(clean: Bool,
                 contractSymbol: String,
-                entryPrice: Double,
                 currentPrice: Double,
-                profitPercentage: Double,
+                entryPrice: Double,
+                exchange: SwiftTraderExchange,
+                isLong: Bool,
+                ticker: String,
+                tickerSize: String,
                 offset: Double,
-                clean: Bool) {
+                profitPercentage: Double
+    ) {
+        self.clean = clean
+        self.contractSymbol = contractSymbol
+        self.currentPrice = currentPrice
+        self.entryPrice = entryPrice
         self.exchange = exchange
+        self.isLong = isLong
         self.ticker = ticker
         self.tickerSize = tickerSize
-        self.contractSymbol = contractSymbol
-        self.entryPrice = entryPrice
-        self.currentPrice = currentPrice
-        self.profitPercentage = profitPercentage
         self.offset = offset
-        self.clean = clean
+        self.profitPercentage = profitPercentage
     }
 }

Sources/SwiftTrader/SwiftTrader+TrailingStop.swift

@@ -41,8 +41,12 @@ public extension SwiftTrader {
         let priceIncrement: Double = input.entryPrice * targetPercentage
         logger.log("Price increment: \(priceIncrement.toDecimalString())")
 
-        // E.g.: 42000.69 + 2830.846506 = 44831.536506
-        let targetPrice: Double = input.entryPrice + priceIncrement
+        // "Long" example: 42000.69 + 2830.846506 = 44831.536506
+        // "Short" example: 42000.69 - 2830.846506 = 39169.843494
+        let targetPrice: Double = input.isLong ?
+        input.entryPrice + priceIncrement :
+        input.entryPrice - priceIncrement
+        
         logger.log("Entry price: \(input.entryPrice.toDecimalString())")
         logger.log("Target price: \(targetPrice.toDecimalString())")
 
@@ -95,19 +99,29 @@ public extension SwiftTrader {
         logger.log("Ticker size: \(input.tickerSize)")
         logger.log("Target price string: \(targetPriceString)")
 
-        // Throw in case the target price became lower than the entry price for whatever reason.
-        // Do not place an order in this scenario.
-        guard Double(targetPriceString) ?? 0 > input.entryPrice else {
-            throw SwiftTraderError.kucoinInvalidTargetPrice(
-                entryPrice: input.entryPrice.toDecimalString(),
-                targetPrice: targetPriceString)
+        if input.isLong {
+            guard Double(targetPriceString) ?? 0 > input.entryPrice else {
+                // Long position: throw in case the target price became LOWER than the entry price
+                // for whatever reason. Do not place an order in this scenario.
+                throw SwiftTraderError.kucoinInvalidTargetPriceLower(
+                    entryPrice: input.entryPrice.toDecimalString(),
+                    targetPrice: targetPriceString)
+            }
+        } else {
+            guard Double(targetPriceString) ?? 0 < input.entryPrice else {
+                // Short position: throw in case the target price became HIGHER than the entry price
+                // for whatever reason. Do not place an order in this scenario.
+                throw SwiftTraderError.kucoinInvalidTargetPriceHigher(
+                    entryPrice: input.entryPrice.toDecimalString(),
+                    targetPrice: targetPriceString)
+            }
         }
 
         return KucoinOrderParameters(
             symbol: input.contractSymbol,
             side: .sell,
             type: .limit,
-            stop: .down,
+            stop: input.isLong ? .down : .up,
             stopPriceType: .TP,
             stopPrice: "\(targetPriceString)",
             price: "\(targetPriceString)",