react-native-zcash 0.3.3 → 0.3.5

package/ios/ZCashLightClientKit/Block/Downloader/CompactBlockDownloaderBuilder.swift

@@ -0,0 +1,26 @@
+//
+//  CompactBlockDownloaderBuilder.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/18/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+import SQLite
+
+extension CompactBlockDownloader {
+    static func sqlDownloader(service: LightWalletService, at url: URL) -> CompactBlockDownloader? {
+        let storage = CompactBlockStorage(url: url, readonly: false)
+        
+        guard (try? storage.createTable()) != nil else { return nil }
+        
+        return CompactBlockDownloader(service: service, storage: storage)
+    }
+}
+
+extension CompactBlockStorage {
+    convenience init(url: URL, readonly: Bool) {
+        self.init(connectionProvider: SimpleConnectionProvider(path: url.absoluteString, readonly: readonly))
+    }
+}

package/ios/ZCashLightClientKit/Block/Processor/CompactBlockDownloadOperation.swift

@@ -0,0 +1,258 @@
+//
+//  CompactBlockDownloadOperation.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/16/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+class CompactBlockDownloadOperation: ZcashOperation {
+    override var isConcurrent: Bool { false }
+    override var isAsynchronous: Bool { false }
+    
+    private var downloader: CompactBlockDownloading
+    private var range: CompactBlockRange
+    
+    required init(downloader: CompactBlockDownloading, range: CompactBlockRange) {
+        self.range = range
+        self.downloader = downloader
+        super.init()
+        self.name = "Download Operation: \(range)"
+    }
+    
+    override func main() {
+        guard !shouldCancel() else {
+            cancel()
+            return
+        }
+        self.startedHandler?()
+        do {
+            try downloader.downloadBlockRange(range)
+        } catch {
+            self.error = error
+            self.fail()
+        }
+    }
+}
+
+protocol CompactBlockProgressDelegate: AnyObject {
+    func progressUpdated(_ progress: CompactBlockProgress)
+}
+
+class CompactBlockStreamDownloadOperation: ZcashOperation {
+    enum CompactBlockStreamDownloadOperationError: Error {
+        case startHeightMissing
+    }
+
+    override var isConcurrent: Bool { false }
+    override var isAsynchronous: Bool { false }
+    
+    private var storage: CompactBlockStorage
+    private var service: LightWalletService
+    private var done = false
+    private var cancelable: CancellableCall?
+    private var startHeight: BlockHeight?
+    private var targetHeight: BlockHeight?
+
+    private weak var progressDelegate: CompactBlockProgressDelegate?
+
+    required init(
+        service: LightWalletService,
+        storage: CompactBlockStorage,
+        startHeight: BlockHeight? = nil,
+        targetHeight: BlockHeight? = nil,
+        progressDelegate: CompactBlockProgressDelegate? = nil
+    ) {
+        self.storage = storage
+        self.service = service
+        self.startHeight = startHeight
+        self.targetHeight = targetHeight
+        self.progressDelegate = progressDelegate
+        super.init()
+        self.name = "Download Stream Operation"
+    }
+    
+    // swiftlint:disable cyclomatic_complexity
+    override func main() {
+        guard !shouldCancel() else {
+            cancel()
+            return
+        }
+        self.startedHandler?()
+        do {
+            if self.targetHeight == nil {
+                self.targetHeight = try service.latestBlockHeight()
+            }
+            guard let latestHeight = self.targetHeight else {
+                throw LightWalletServiceError.generalError(message: "missing target height on block stream operation")
+            }
+            let latestDownloaded = try storage.latestHeight()
+            let startHeight = max(self.startHeight ?? BlockHeight.empty(), latestDownloaded)
+            
+            self.cancelable = self.service.blockStream(startHeight: startHeight, endHeight: latestHeight) { [weak self] blockResult in
+                switch blockResult {
+                case .success(let result):
+                    switch result {
+                    case .success:
+                        self?.done = true
+                        return
+                    case .error(let e):
+                        self?.fail(error: e)
+                    }
+                case .failure(let e):
+                    if case .userCancelled = e {
+                        self?.done = true
+                    } else {
+                        self?.fail(error: e)
+                    }
+                }
+            } handler: {[weak self] block in
+                guard let self = self else { return }
+                do {
+                    try self.storage.insert(block)
+                } catch {
+                    self.fail(error: error)
+                }
+            } progress: { progress in
+                self.progressDelegate?.progressUpdated(.download(progress))
+            }
+            
+            while !done && !isCancelled {
+                sleep(1)
+            }
+        } catch {
+            self.fail(error: error)
+        }
+    }
+
+    override func fail(error: Error? = nil) {
+        self.cancelable?.cancel()
+        super.fail(error: error)
+    }
+    
+    override func cancel() {
+        self.cancelable?.cancel()
+        super.cancel()
+    }
+}
+
+class CompactBlockBatchDownloadOperation: ZcashOperation {
+    enum CompactBlockBatchDownloadOperationError: Error {
+        case startHeightMissing
+        case batchDownloadFailed(range: CompactBlockRange, error: Error?)
+    }
+
+    override var isConcurrent: Bool { false }
+    override var isAsynchronous: Bool { false }
+    
+    private var batch: Int
+    private var maxRetries: Int
+    private var storage: CompactBlockStorage
+    private var service: LightWalletService
+    private var cancelable: CancellableCall?
+    private var startHeight: BlockHeight
+    private var targetHeight: BlockHeight
+
+    private weak var progressDelegate: CompactBlockProgressDelegate?
+
+    required init(
+        service: LightWalletService,
+        storage: CompactBlockStorage,
+        startHeight: BlockHeight,
+        targetHeight: BlockHeight,
+        batchSize: Int = 100,
+        maxRetries: Int = 5,
+        progressDelegate: CompactBlockProgressDelegate? = nil
+    ) {
+        self.storage = storage
+        self.service = service
+        self.startHeight = startHeight
+        self.targetHeight = targetHeight
+        self.progressDelegate = progressDelegate
+        self.batch = batchSize
+        self.maxRetries = maxRetries
+        super.init()
+        self.name = "Download Batch Operation"
+    }
+    
+    override func main() {
+        guard !shouldCancel() else {
+            cancel()
+            return
+        }
+        self.startedHandler?()
+        do {
+            let localDownloadedHeight = try self.storage.latestHeight()
+            
+            if localDownloadedHeight != BlockHeight.empty() && localDownloadedHeight > startHeight {
+                LoggerProxy.warn("provided startHeight (\(startHeight)) differs from local latest downloaded height (\(localDownloadedHeight))")
+                startHeight = localDownloadedHeight + 1
+            }
+            
+            var currentHeight = startHeight
+            self.progressDelegate?.progressUpdated(
+                .download(
+                    BlockProgress(
+                        startHeight: currentHeight,
+                        targetHeight: targetHeight,
+                        progressHeight: currentHeight
+                    )
+                )
+            )
+            
+            while !isCancelled && currentHeight <= targetHeight {
+                var retries = 0
+                var success = true
+                var localError: Error?
+            
+                let range = nextRange(currentHeight: currentHeight, targetHeight: targetHeight)
+                
+                repeat {
+                    do {
+                        let blocks = try service.blockRange(range)
+                        try storage.insert(blocks)
+                        success = true
+                    } catch {
+                        success = false
+                        localError = error
+                        retries += 1
+                    }
+                } while !isCancelled && !success && retries < maxRetries
+
+                if retries >= maxRetries {
+                    throw CompactBlockBatchDownloadOperationError.batchDownloadFailed(range: range, error: localError)
+                }
+                
+                self.progressDelegate?.progressUpdated(
+                    .download(
+                        BlockProgress(
+                            startHeight: startHeight,
+                            targetHeight: targetHeight,
+                            progressHeight: range.upperBound
+                        )
+                    )
+                )
+
+                currentHeight = range.upperBound + 1
+            }
+        } catch {
+            self.fail(error: error)
+        }
+    }
+
+    override func fail(error: Error? = nil) {
+        self.cancelable?.cancel()
+        super.fail(error: error)
+    }
+
+    override func cancel() {
+        self.cancelable?.cancel()
+        super.cancel()
+    }
+
+    func nextRange(currentHeight: BlockHeight, targetHeight: BlockHeight) -> CompactBlockRange {
+        CompactBlockRange(uncheckedBounds: (lower: currentHeight, upper: min(currentHeight + batch, targetHeight)))
+    }
+}

package/ios/ZCashLightClientKit/Block/Processor/CompactBlockEnhancementOperation.swift

@@ -0,0 +1,157 @@
+//
+//  CompactBlockEnhancementOperation.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 4/10/20.
+//
+
+import Foundation
+
+class CompactBlockEnhancementOperation: ZcashOperation {
+    enum EnhancementError: Error {
+        case noRawData(message: String)
+        case unknownError
+        case decryptError(error: Error)
+        case txIdNotFound(txId: Data)
+    }
+
+    override var isConcurrent: Bool { false }
+    override var isAsynchronous: Bool { false }
+    
+    var rustBackend: ZcashRustBackendWelding.Type
+    var txFoundHandler: (([ConfirmedTransactionEntity], BlockRange) -> Void)?
+    var downloader: CompactBlockDownloading
+    var repository: TransactionRepository
+    var range: BlockRange
+    var maxRetries: Int = 5
+    var retries: Int = 0
+
+    private(set) var network: NetworkType
+    private weak var progressDelegate: CompactBlockProgressDelegate?
+    private var dataDb: URL
+    
+    init(
+        rustWelding: ZcashRustBackendWelding.Type,
+        dataDb: URL,
+        downloader: CompactBlockDownloading,
+        repository: TransactionRepository,
+        range: BlockRange,
+        networkType: NetworkType,
+        progressDelegate: CompactBlockProgressDelegate? = nil
+    ) {
+        rustBackend = rustWelding
+        self.dataDb = dataDb
+        self.downloader = downloader
+        self.repository = repository
+        self.range = range
+        self.progressDelegate = progressDelegate
+        self.network = networkType
+
+        super.init()
+    }
+    
+    override func main() {
+        guard !shouldCancel() else {
+            cancel()
+            return
+        }
+
+        self.startedHandler?()
+
+        // fetch transactions
+        do {
+            guard let transactions = try repository.findTransactions(in: self.range, limit: Int.max), !transactions.isEmpty else {
+                LoggerProxy.debug("no transactions detected on range: \(range.printRange)")
+                return
+            }
+            
+            for index in 0 ..< transactions.count {
+                let transaction = transactions[index]
+                var retry = true
+
+                while retry && self.retries < maxRetries {
+                    do {
+                        let confirmedTx = try enhance(transaction: transaction)
+                        retry = false
+                        self.reportProgress(
+                            totalTransactions: transactions.count,
+                            enhanced: index + 1,
+                            txEnhanced: confirmedTx
+                        )
+                    } catch {
+                        self.retries += 1
+                        LoggerProxy.error("could not enhance txId \(transaction.transactionId.toHexStringTxId()) - Error: \(error)")
+                        if retries > maxRetries {
+                            throw error
+                        }
+                    }
+                }
+            }
+        } catch {
+            LoggerProxy.error("error enhancing transactions! \(error)")
+            self.error = error
+            self.fail()
+            return
+        }
+        
+        if let handler = self.txFoundHandler, let foundTxs = try? repository.findConfirmedTransactions(in: self.range, offset: 0, limit: Int.max) {
+            handler(foundTxs, self.range)
+        }
+    }
+    
+    func reportProgress(totalTransactions: Int, enhanced: Int, txEnhanced: ConfirmedTransactionEntity) {
+        self.progressDelegate?.progressUpdated(
+            .enhance(
+                EnhancementStreamProgress(
+                    totalTransactions: totalTransactions,
+                    enhancedTransactions: enhanced,
+                    lastFoundTransaction: txEnhanced,
+                    range: self.range.compactBlockRange
+                )
+            )
+        )
+    }
+    
+    func enhance(transaction: TransactionEntity) throws -> ConfirmedTransactionEntity {
+        LoggerProxy.debug("Zoom.... Enhance... Tx: \(transaction.transactionId.toHexStringTxId())")
+        
+        let transaction = try downloader.fetchTransaction(txId: transaction.transactionId)
+
+        let transactionID = transaction.transactionId.toHexStringTxId()
+        let block = String(describing: transaction.minedHeight)
+        LoggerProxy.debug("Decrypting and storing transaction id: \(transactionID) block: \(block)")
+        
+        guard let rawBytes = transaction.raw?.bytes else {
+            let error = EnhancementError.noRawData(
+                message: "Critical Error: transaction id: \(transaction.transactionId.toHexStringTxId()) has no data"
+            )
+            LoggerProxy.error("\(error)")
+            throw error
+        }
+        
+        guard let minedHeight = transaction.minedHeight else {
+            let error = EnhancementError.noRawData(
+                message: "Critical Error - Attempt to decrypt and store an unmined transaction. Id: \(transaction.transactionId.toHexStringTxId())"
+            )
+            LoggerProxy.error("\(error)")
+            throw error
+        }
+        
+        guard rustBackend.decryptAndStoreTransaction(dbData: dataDb, txBytes: rawBytes, minedHeight: Int32(minedHeight), networkType: network) else {
+            if let rustError = rustBackend.lastError() {
+                throw EnhancementError.decryptError(error: rustError)
+            }
+            throw EnhancementError.unknownError
+        }
+        guard let confirmedTx = try self.repository.findConfirmedTransactionBy(rawId: transaction.transactionId) else {
+            throw EnhancementError.txIdNotFound(txId: transaction.transactionId)
+        }
+        return confirmedTx
+    }
+}
+
+private extension BlockRange {
+    var printRange: String {
+        "\(self.start.height) ... \(self.end.height)"
+    }
+}