Finish placing MARKET orders within Binance

 - Update order response.
 - Update signee.
 - Make FTX auth optional with nil as default value.

Author: backslash-f

Sources/SwiftTrader/Model/Binance/Order/BinanceSpotNewOrderParameters.swift

@@ -38,4 +38,6 @@ public enum BinanceSpotNewOrderParameterKey: String {
     case side
     case type
     case quoteOrderQty
+    case timestamp
+    case signature
 }

Sources/SwiftTrader/Model/Binance/Order/BinanceSpotNewOrderResponse.swift

@@ -17,17 +17,16 @@ public struct BinanceSpotNewOrderResponse: Codable {
     let transactTime: Int
     let price, origQty, executedQty, cummulativeQuoteQty: String
     let status, timeInForce, type, side: String
-    let strategyID, strategyType: Int
+    let workingTime: Int
     let fills: [BinanceOrderFill]
+    let selfTradePreventionMode: String
 
     enum CodingKeys: String, CodingKey {
         case symbol
         case orderID = "orderId"
         case orderListID = "orderListId"
         case clientOrderID = "clientOrderId"
-        case transactTime, price, origQty, executedQty, cummulativeQuoteQty, status, timeInForce, type, side
-        case strategyID = "strategyId"
-        case strategyType, fills
+        case transactTime, price, origQty, executedQty, cummulativeQuoteQty, status, timeInForce, type, side, workingTime, fills, selfTradePreventionMode
     }
 }
 

Sources/SwiftTrader/Network/Binance/Orders/PlaceOrder/BinanceSpotNewOrderRequest.swift

@@ -32,14 +32,21 @@ public struct BinanceSpotNewOrderRequest: NetworkRequest {
             var urlRequest = URLRequest(url: try spotNewOrderResource.url)
             urlRequest.httpMethod = HTTPMethod.POST.rawValue
 
-            // Parameters.
-            let dataParameter = try createDataParameter(from: orderParameters)
-            urlRequest.httpBody = dataParameter
+            // Body parameters.
+            let stringParameters = createStringParameters(from: orderParameters)
+            let dataParameters = try createDataParameter(from: stringParameters)
+            
+            // Signature parameter.
+            let stringSignature = try createSignature(for: dataParameters, binanceAuth: binanceAuth)
+            let dataSignature = try createDataParameter(from: stringParameters + "&\(stringSignature)")
+            
+            // Add the parameters.
+            urlRequest.httpBody = dataSignature
+            
+            // Add header fields.
             urlRequest.addValue(HTTPHeader.Value.urlEncoded, forHTTPHeaderField: HTTPHeader.Field.contentType)
             try BinanceAPI.setRequestHeaderFields(request: &urlRequest, binanceAuth: binanceAuth.spot)
 
-#warning("TODO: Add signature - here?")
-            
             return urlRequest
         }
     }
@@ -85,21 +92,34 @@ public extension BinanceSpotNewOrderRequest {
 
 private extension BinanceSpotNewOrderRequest {
 
-    func createDataParameter(from orderParameters: BinanceSpotNewOrderParameters) throws -> Data {
-        let symbolParameter = "\(BinanceSpotNewOrderParameterKey.symbol.rawValue)=\(orderParameters.symbol)"
-        let sideParameter = "\(BinanceSpotNewOrderParameterKey.side.rawValue)=\(orderParameters.side)"
-        let typeParameter = "\(BinanceSpotNewOrderParameterKey.type.rawValue)=\(orderParameters.type)"
-        let quoteQtyParameter = "\(BinanceSpotNewOrderParameterKey.quoteOrderQty.rawValue)=\(orderParameters.quoteOrderQty)"
-        
-#warning("TODO: Add timestamp")
-        
-        // E.g.: "symbol=BTCUSDT&side=buy&type=market&quoteOrderQty=100.0"
-        let stringParameter = "\(symbolParameter)&\(sideParameter)&\(typeParameter)&\(quoteQtyParameter)"
-        
-        if let dataParameter = stringParameter.data(using: .utf8) {
-            return dataParameter
+    /// Creates the `String` parameters to be later added into the request body.
+    ///
+    /// For example: *symbol=BTCUSDT&side=buy&type=market&quoteOrderQty=100.0&timestamp=1670998246731*
+    ///
+    func createStringParameters(from orderParameters: BinanceSpotNewOrderParameters) -> String {
+        let symbolParam     = "\(BinanceSpotNewOrderParameterKey.symbol.rawValue)=\(orderParameters.symbol)"
+        let sideParam       = "\(BinanceSpotNewOrderParameterKey.side.rawValue)=\(orderParameters.side)"
+        let typeParam       = "\(BinanceSpotNewOrderParameterKey.type.rawValue)=\(orderParameters.type)"
+        let quoteQtyParam   = "\(BinanceSpotNewOrderParameterKey.quoteOrderQty.rawValue)=\(orderParameters.quoteOrderQty)"
+        let timestampParam  = "\(BinanceSpotNewOrderParameterKey.timestamp.rawValue)=\(Date().timestampMilliseconds)"
+    
+        return "\(symbolParam)&\(sideParam)&\(typeParam)&\(quoteQtyParam)&\(timestampParam)"
+    }
+    
+    /// Creates the `Data` parameter to be added into the request body via `urlRequest.httpBody = dataParameter`.
+    func createDataParameter(from string: String) throws -> Data {
+        if let data = string.data(using: .utf8) {
+            return data
         } else {
-            throw NetworkRequestError.invalidDataFromString(string: stringParameter)
+            throw NetworkRequestError.invalidDataFromString(string: string)
         }
     }
+    
+    func createSignature(for data: Data, binanceAuth: BinanceAuth) throws -> String {
+        let signature = try NetworkRequestSignee.createHMACSignature(for: data,
+                                                                     secret: binanceAuth.spot.apiSecret,
+                                                                     isHexString: true)
+        let symbolParam = "\(BinanceSpotNewOrderParameterKey.signature.rawValue)=\(signature)"
+        return symbolParam
+    }
 }

Sources/SwiftTrader/Network/Util/Signee.swift

@@ -44,6 +44,24 @@ public struct NetworkRequestSignee {
         )
         request.setValue(signature, forHTTPHeaderField: httpHeaderField)
     }
+    
+    /// Creates a `SHA256 HMAC` signature using the given `secret`.
+    ///
+    /// - Parameters:
+    ///   - data: The `Data` to be signed. This for example could be `Data` from a `String`
+    ///   using `stringToSign.data(using: .utf8)`. The `String` contains the parameters
+    ///   that require signing. Taking Binance as an example, that would be something like
+    ///   "symbol=BTCUSDT&side=buy&type=market&quoteOrderQty=100.0&timestamp=1670998246731".
+    ///   - secret: The API secret required to sign the request.
+    ///   - isHexString: if `true`, then the generated String signature will be encoded using `Data.hexStringEncoded()`.
+    ///   If `false` (the default), then `Data.base64EncodedString()` will be used instead.
+    static func createHMACSignature(for data: Data,
+                                    secret: String,
+                                    isHexString: Bool = false) throws -> String {
+        let key = try createSymmetricKey(from: secret)
+        let signature = HMAC<SHA256>.authenticationCode(for: data, using: key)
+        return isHexString ? Data(signature).hexStringEncoded() : Data(signature).base64EncodedString()
+    }
 }
 
 // MARK: - Private
@@ -88,21 +106,22 @@ private extension NetworkRequestSignee {
     }
 
     static func createHMACSignature(for method: HTTPMethod,
-                                path: String,
-                                body: String,
-                                secret: String,
-                                isHexString: Bool = false) throws -> String {
-        guard let secretData = secret.data(using: .utf8) else {
-            throw NetworkRequestError.stringToDataFailed(string: secret)
-        }
-        let key = SymmetricKey(data: secretData)
+                                    path: String,
+                                    body: String,
+                                    secret: String,
+                                    isHexString: Bool = false) throws -> String {
         let timestamp = Date().timestampMilliseconds
         let stringToSign = "\(timestamp)" + method.rawValue + path + body
         guard let stringToSignData = stringToSign.data(using: .utf8) else {
             throw NetworkRequestError.stringToDataFailed(string: stringToSign)
         }
-        let signature = HMAC<SHA256>.authenticationCode(for: stringToSignData, using: key)
-        return isHexString ? Data(signature).hexStringEncoded() : Data(signature).base64EncodedString()
+        return try createHMACSignature(for: stringToSignData, secret: secret, isHexString: isHexString)
+    }
+    
+    static func createSymmetricKey(from secret: String) throws -> SymmetricKey {
+        guard let secretData = secret.data(using: .utf8) else {
+            throw NetworkRequestError.stringToDataFailed(string: secret)
+        }
+        return SymmetricKey(data: secretData)
     }
 }
-

Sources/SwiftTrader/SwiftTrader+BinanceSpot.swift

@@ -16,6 +16,8 @@ public extension SwiftTrader {
     ///
     /// https://binance-docs.github.io/apidocs/spot/en/#new-order-trade
     ///
+    /// Notice: only MARKET orders are supported for the time being.
+    ///
     /// - Parameter orderInput: `BinanceSpotNewOrderParameters` instance that encapsulates
     /// all the arguments required for submiting the order.
     /// - Returns: An instance of `BinanceNewOrderResponse` or `SwiftTraderError`.
@@ -33,14 +35,6 @@ public extension SwiftTrader {
             guard let placeOrder = model as? BinanceSpotNewOrderResponse else {
                 return .failure(.unexpectedResponse(modelString: "\(model)"))
             }
-#warning("TODO: how to handle cancelling order within Binance")
-            //            if orderInput.cancelStopOrders {
-            //                do {
-            //                    try await kucoinSpotCancelStopOrders(symbol: orderInput.contractSymbol)
-            //                } catch {
-            //                    logger.log("Could not cancel untriggered stop orders: \(error)")
-            //                }
-            //            }
             return .success(placeOrder)
         case .failure(let error):
             let swiftTraderError = handle(networkRequestError: error, operation: .binanceSpotNewOrder)

Sources/SwiftTrader/SwiftTrader.swift

@@ -22,7 +22,7 @@ public struct SwiftTrader {
     // MARK: - Lifecycle
 
     public init(binanceAuth: BinanceAuth,
-                ftxAuth: FTXAuth?,
+                ftxAuth: FTXAuth? = nil,
                 kucoinAuth: KucoinAuth?,
                 settings: SwiftTraderSettings = DefaultSwiftTraderSettings()) {
         self.binanceAuth = binanceAuth