DP-701 queue

KinSDK/KinSDK/Assets.swift

@@ -0,0 +1,45 @@
+//
+//  Asset.swift
+//  KinSDK
+//
+//  Created by Corey Werner on 20/08/2019.
+//  Copyright © 2019 Kin Foundation. All rights reserved.
+//
+
+import Foundation
+
+/**
+ Kin is the native currency of the network.
+ */
+public typealias Kin = Decimal
+
+extension Kin {
+    /**
+     Convert `Kin` into `Quark`.
+
+     This value should only be used to fees.
+     */
+    public func toQuark() -> Quark {
+        return (self * Decimal(AssetUnitDivisor) as NSDecimalNumber).uint32Value
+    }
+
+    func toQuarkAsBlockchainUnit() -> Int64 {
+        return (self * Decimal(AssetUnitDivisor) as NSDecimalNumber).int64Value
+    }
+}
+
+/**
+ Quark is the smallest amount unit. It is one-hundred-thousandth of a Kin: `1/100000` or `0.00001`.
+ */
+public typealias Quark = UInt32
+
+extension Quark {
+    public func toKin() -> Kin {
+        return Decimal(self) / Decimal(AssetUnitDivisor)
+    }
+}
+
+@available(*, deprecated, renamed: "Quark")
+public typealias Stroop = Quark
+
+let AssetUnitDivisor: UInt32 = 100_000

KinSDK/KinSDK/BulkPayments/BatchPaymentTransaction.swift

@@ -9,12 +9,33 @@
 import Foundation
 
 public class BatchPaymentTransaction: BaseTransaction {
-    public var payments: [PaymentOperation] {
-        return []
+    public let payments: [PaymentOperation]
+
+    private static func findPaymentOperations(operations: [Operation]) -> [PaymentOp]? {
+        var paymentOperations: [PaymentOp] = []
+
+        for operation in operations {
+            if case let Operation.Body.PAYMENT(paymentOperation) = operation.body {
+                paymentOperations.append(paymentOperation)
+            }
+        }
+
+        return paymentOperations.count > 0 ? paymentOperations : nil
+    }
+
+    required init(tryWrapping transaction: Transaction, sourcePublicAddress: String) throws {
+        guard let operations = BatchPaymentTransaction.findPaymentOperations(operations: transaction.operations) else {
+            throw StellarError.decodeTransactionFailed
+        }
+
+        self.payments = operations.map({ operation -> PaymentOperation in
+            return PaymentOperation(sourcePublicAddress: sourcePublicAddress, destinationPublicAddress: operation.destination.publicKey, amount: Kin(operation.amount))
+        })
+
+        super.init(wrapping: transaction)
     }
 
-    public var memo: String {
-        return ""
+    public var memo: String? {
+        return transaction.memo.text
     }
 }
-

KinSDK/KinSDK/BulkPayments/PaymentOperation.swift

@@ -9,7 +9,7 @@
 import Foundation
 
 public struct PaymentOperation {
-    public let source: String
-    public let destination: String
+    public let sourcePublicAddress: String
+    public let destinationPublicAddress: String
     public let amount: Kin
 }

KinSDK/KinSDK/BulkPayments/PaymentQueue.swift

@@ -9,83 +9,98 @@
 import Foundation
 
 public protocol PaymentQueueDelegate: NSObjectProtocol {
-    func paymentEnqueued(pendingPayment: PaymentQueue.PendingPayment)
-    func transactionSend(transaction: BatchPaymentTransaction, payments: [PaymentQueue.PendingPayment])
-    func transactionSendSuccess(transaction: BatchPaymentTransaction, payments: [PaymentQueue.PendingPayment])
-    func transactionSendFailed(transaction: BatchPaymentTransaction, payments: [PaymentQueue.PendingPayment], error: Error)
+    func paymentEnqueued(pendingPayment: PendingPayment)
+    func transactionSend(transaction: BatchPaymentTransaction, payments: [PendingPayment])
+    func transactionSendSuccess(transaction: BatchPaymentTransaction, payments: [PendingPayment])
+    func transactionSendFailed(transaction: BatchPaymentTransaction, payments: [PendingPayment], error: Error)
 }
 
-public class PaymentQueue {
-    public weak var delegate: PaymentQueue?
+public class PaymentQueue: NSObject {
+    public weak var delegate: PaymentQueueDelegate?
 
-    public func enqueuePayment(publicAddress: String, amount: Kin, metadata: AnyObject? = nil) throws {
+    let stellar: StellarProtocol
+    let stellarAccount: StellarAccount
 
-    }
+    private let paymentsQueueManager = PaymentsQueueManager()
+    private lazy var transactionTasksQueueManager: TransactionTasksQueueManager = {
+        return TransactionTasksQueueManager(stellar: stellar, stellarAccount: stellarAccount)
+    }()
+
+    init(stellar: StellarProtocol, stellarAccount: StellarAccount) {
+        self.stellar = stellar
+        self.stellarAccount = stellarAccount
 
-    public func setTransactionInterceptor(_ interceptor: TransactionInterceptor) {
+        super.init()
 
+        paymentsQueueManager.delegate = self
     }
 
-    public var fee: Int = 0 {
-        didSet {
+    // MARK: Enqueuing
 
-        }
-    }
+    public func enqueuePayment(publicAddress: String, amount: Kin, metadata: AnyObject? = nil) throws -> PendingPayment {
+        let pendingPayment = PendingPayment(destinationPublicAddress: publicAddress, sourcePublicAddress: stellarAccount.publicAddress, amount: amount, metadata: metadata)
 
-    public var status: Status {
-        return Status()
-    }
-}
+        paymentsQueueManager.enqueue(pendingPayment: pendingPayment)
 
-extension PaymentQueue {
-    public class Status {
-        public var transactionInProgress: Bool {
-            return false
-        }
+        return pendingPayment
+    }
 
-        public var pendingPaymentsCount: Int {
-            return 0
+    func enqueueTransactionParams(_ params: SendTransactionParams, completion: @escaping (Result<TransactionId, Error>) -> Void) {
+        DispatchQueue.global(qos: .utility).async {
+            let transactionParamsOperation = self.transactionTasksQueueManager.enqueue(transactionParams: params)
+
+            transactionParamsOperation.completionBlock = {
+                DispatchQueue.main.async {
+                    if transactionParamsOperation.isCancelled {
+                        completion(.failure(KinError.transactionOperationCancelled))
+                        return
+                    }
+
+                    guard let result = transactionParamsOperation.result else {
+                        // This should never happen.
+                        completion(.failure(KinError.internalInconsistency))
+                        return
+                    }
+
+                    completion(result)
+                }
+            }
         }
     }
-}
 
-extension PaymentQueue {
-    // ???: change to struct
-    public class PendingPayment {
-        public var destinationPublicKey: String {
-            return ""
-        }
+    // MARK: Inspecting
 
-        public var sourcePublicKey: String {
-            return ""
-        }
-
-        public var amount: Kin {
-            return 0
-        }
+    public var transactionInProgress: Bool {
+        return transactionTasksQueueManager.inProgress
+    }
 
-        public var operationIndex: Int {
-            return 0
-        }
+    public var pendingPaymentsCount: Int {
+        return paymentsQueueManager.operationsCount
+    }
 
-        public func transaction() -> BatchPaymentTransaction {
-            return nil!
-        }
+    // MARK: Operation Properties
 
-        public var metaData: Any {
-            return {}
-        }
+    /**
+     - Note: The delegate functions will be called from a background thread.
+     */
+    weak public var transactionInterceptor: TransactionInterceptor?
 
-        public var status: Status {
-            return .pending
-        }
-    }
+    public var fee: Quark = 0
 }
 
-extension PaymentQueue.PendingPayment {
-    public enum Status {
-        case pending
-        case completed
-        case failed
+extension PaymentQueue: PaymentsQueueManagerDelegate {
+    func paymentsQueueManager(_ manager: PaymentsQueueManager, dequeueing pendingPayments: [PendingPayment]) {
+        DispatchQueue.global(qos: .utility).async {
+            func enqueue() {
+                self.transactionTasksQueueManager.enqueue(pendingPayments: pendingPayments, fee: self.fee, transactionInterceptor: self.transactionInterceptor)
+            }
+
+            if self.fee == 0 {
+                self.stellar.minFee().then({ self.fee = $0 }).finally({ enqueue() })
+            }
+            else {
+                enqueue()
+            }
+        }
     }
 }

KinSDK/KinSDK/BulkPayments/PaymentQueueTransactionProcess.swift

@@ -0,0 +1,59 @@
+//
+//  PaymentQueueTransactionProcess.swift
+//  KinSDK
+//
+//  Created by Corey Werner on 05/09/2019.
+//  Copyright © 2019 Kin Foundation. All rights reserved.
+//
+
+import Foundation
+
+public class PaymentQueueTransactionProcess: TransactionProcess {
+    public let pendingPayments: [PendingPayment]
+    let fee: Quark
+    let stellarAccount: StellarAccount
+
+    init(pendingPayments: [PendingPayment], fee: Quark, stellar: StellarProtocol, stellarAccount: StellarAccount) {
+        self.pendingPayments = pendingPayments
+        self.fee = fee
+        self.stellarAccount = stellarAccount
+
+        super.init(stellar: stellar)
+    }
+
+    public override func transaction() throws -> BatchPaymentTransaction {
+        return try transaction(memo: nil)
+    }
+
+    public func transaction(memo memoString: String?) throws -> BatchPaymentTransaction {
+        let dispatchGroup = DispatchGroup()
+        dispatchGroup.enter()
+
+        var result: Result<BatchPaymentTransaction, Error> = .failure(KinError.internalInconsistency)
+
+        var memo: Memo = .MEMO_NONE
+
+        if let memoString = memoString {
+            memo = try Memo(memoString)
+        }
+
+        stellar.transaction(sourceStellarAccount: stellarAccount, pendingPayments: pendingPayments, memo: memo, fee: fee)
+            .then { transaction in
+                result = .success(transaction)
+                dispatchGroup.leave()
+            }
+            .error { error in
+                result = .failure(error)
+                dispatchGroup.leave()
+        }
+
+        dispatchGroup.wait()
+
+        switch result {
+        case .success(let transaction):
+            return transaction
+        case .failure(let error):
+            throw error
+        }
+    }
+}

KinSDK/KinSDK/BulkPayments/PaymentsQueueManager.swift

@@ -0,0 +1,83 @@
+//
+//  PaymentsQueueManager.swift
+//  KinSDK
+//
+//  Created by Corey Werner on 15/08/2019.
+//  Copyright © 2019 Kin Foundation. All rights reserved.
+//
+
+import Foundation
+
+protocol PaymentsQueueManagerDelegate: NSObjectProtocol {
+    func paymentsQueueManager(_ manager: PaymentsQueueManager, dequeueing pendingPayments: [PendingPayment])
+}
+
+class PaymentsQueueManager {
+    let maxPendingPayments = TransactionTasksQueueManager.maxPendingPaymentCount
+    let maxPaymentsTime: TimeInterval
+    let maxTimeoutTime: TimeInterval
+    private var paymentsTimer: Timer?
+    private var timeoutTimer: Timer?
+    private var payments: [PendingPayment] = []
+
+    weak var delegate: PaymentsQueueManagerDelegate?
+
+    init(maxPaymentsTime: TimeInterval = 4, maxTimeoutTime: TimeInterval = 10) {
+        self.maxPaymentsTime = maxPaymentsTime
+        self.maxTimeoutTime = maxTimeoutTime
+    }
+
+    var inProgress: Bool {
+        return timeoutTimer != nil || paymentsTimer != nil
+    }
+
+    var operationsCount: Int {
+        return payments.count
+    }
+
+    func enqueue(pendingPayment: PendingPayment) {
+        func enqueu() {
+            updateTimers()
+
+            payments.append(pendingPayment)
+
+            if operationsCount >= maxPendingPayments {
+                dequeue()
+            }
+        }
+
+        if Thread.isMainThread {
+            enqueu()
+        }
+        else {
+            DispatchQueue.main.async {
+                enqueu()
+            }
+        }
+    }
+
+    @objc private func dequeue() {
+        removeTimers()
+
+        delegate?.paymentsQueueManager(self, dequeueing: payments)
+
+        payments.removeAll()
+    }
+
+    private func updateTimers() {
+        if timeoutTimer == nil {
+            timeoutTimer = .scheduledTimer(timeInterval: maxTimeoutTime, target: self, selector: #selector(dequeue), userInfo: nil, repeats: false)
+        }
+
+        paymentsTimer?.invalidate()
+        paymentsTimer = .scheduledTimer(timeInterval: maxPaymentsTime, target: self, selector: #selector(dequeue), userInfo: nil, repeats: false)
+    }
+
+    private func removeTimers() {
+        timeoutTimer?.invalidate()
+        timeoutTimer = nil
+
+        paymentsTimer?.invalidate()
+        paymentsTimer = nil
+    }
+}