react-native-zcash 0.3.4 → 0.3.5

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

@@ -0,0 +1,238 @@
+//
+//  CompactBlockProcessingOperation.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/15/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+class CompactBlockScanningOperation: ZcashOperation {
+    override var isConcurrent: Bool { false }
+    
+    override var isAsynchronous: Bool { false }
+    
+    var rustBackend: ZcashRustBackendWelding.Type
+    
+    private var cacheDb: URL
+    private var dataDb: URL
+    private var limit: UInt32
+    private var network: NetworkType
+    init(rustWelding: ZcashRustBackendWelding.Type, cacheDb: URL, dataDb: URL, limit: UInt32 = 0, networkType: NetworkType) {
+        rustBackend = rustWelding
+        self.cacheDb = cacheDb
+        self.dataDb = dataDb
+        self.limit = limit
+        self.network = networkType
+        super.init()
+    }
+    
+    override func main() {
+        guard !shouldCancel() else {
+            cancel()
+            return
+        }
+        self.startedHandler?()
+        guard self.rustBackend.scanBlocks(dbCache: self.cacheDb, dbData: self.dataDb, limit: limit, networkType: network) else {
+            self.error = self.rustBackend.lastError() ?? ZcashOperationError.unknown
+            LoggerProxy.debug("block scanning failed with error: \(String(describing: self.error))")
+            self.fail()
+            return
+        }
+    }
+}
+
+public enum SDKMetrics {
+    struct BlockMetricReport {
+        var startHeight: BlockHeight
+        var targetHeight: BlockHeight
+        var duration: TimeInterval
+        var task: TaskReported
+    }
+    
+    enum TaskReported: String {
+        case scanBlocks
+    }
+
+    static let startBlockHeightKey = "SDKMetrics.startBlockHeightKey"
+    static let targetBlockHeightKey = "SDKMetrics.targetBlockHeightKey"
+    static let progressHeightKey = "SDKMetrics.progressHeight"
+    static let startDateKey = "SDKMetrics.startDateKey"
+    static let endDateKey = "SDKMetrics.endDateKey"
+    static let taskReportedKey = "SDKMetrics.taskReported"
+    static let notificationName = Notification.Name("SDKMetrics.Notification")
+    
+    static func blockReportFromNotification(_ notification: Notification) -> BlockMetricReport? {
+        guard
+            notification.name == notificationName,
+            let info = notification.userInfo,
+            let startHeight = info[startBlockHeightKey] as? BlockHeight,
+            let targetHeight = info[targetBlockHeightKey] as? BlockHeight,
+            let task = info[taskReportedKey] as? TaskReported,
+            let startDate = info[startDateKey] as? Date,
+            let endDate = info[endDateKey] as? Date
+        else {
+            return nil
+        }
+        
+        return BlockMetricReport(
+            startHeight: startHeight,
+            targetHeight: targetHeight,
+            duration: abs(
+                startDate.timeIntervalSinceReferenceDate - endDate.timeIntervalSinceReferenceDate
+            ),
+            task: task
+        )
+    }
+    
+    static func progressReportNotification(
+        progress: BlockProgress,
+        start: Date,
+        end: Date,
+        task: SDKMetrics.TaskReported
+    ) -> Notification {
+        var notification = Notification(name: notificationName)
+        notification.userInfo = [
+            startBlockHeightKey: progress.startHeight,
+            targetBlockHeightKey: progress.targetHeight,
+            progressHeightKey: progress.progressHeight,
+            startDateKey: start,
+            endDateKey: end,
+            taskReportedKey: task
+        ]
+        
+        return notification
+    }
+}
+
+extension String.StringInterpolation {
+    mutating func appendInterpolation(_ value: SDKMetrics.BlockMetricReport) {
+        let literal = "\(value.task) - \(abs(value.startHeight - value.targetHeight)) processed on \(value.duration) seconds"
+        appendLiteral(literal)
+    }
+}
+
+class CompactBlockBatchScanningOperation: ZcashOperation {
+    override var isConcurrent: Bool { false }
+    override var isAsynchronous: Bool { false }
+    
+    var rustBackend: ZcashRustBackendWelding.Type
+
+    private var cacheDb: URL
+    private var dataDb: URL
+    private var batchSize: UInt32
+    private var blockRange: CompactBlockRange
+    private var transactionRepository: TransactionRepository
+    private var network: NetworkType
+
+    private weak var progressDelegate: CompactBlockProgressDelegate?
+    
+    init(
+        rustWelding: ZcashRustBackendWelding.Type,
+        cacheDb: URL,
+        dataDb: URL,
+        transactionRepository: TransactionRepository,
+        range: CompactBlockRange,
+        batchSize: UInt32 = 100,
+        networkType: NetworkType,
+        progressDelegate: CompactBlockProgressDelegate? = nil
+    ) {
+        rustBackend = rustWelding
+        self.cacheDb = cacheDb
+        self.dataDb = dataDb
+        self.transactionRepository = transactionRepository
+        self.blockRange = range
+        self.batchSize = batchSize
+        self.progressDelegate = progressDelegate
+        self.network = networkType
+        super.init()
+    }
+    
+    override func main() {
+        guard !shouldCancel() else {
+            cancel()
+            return
+        }
+
+        self.startedHandler?()
+
+        do {
+            if batchSize == 0 {
+                let scanStartTime = Date()
+                guard self.rustBackend.scanBlocks(dbCache: self.cacheDb, dbData: self.dataDb, limit: batchSize, networkType: network) else {
+                    self.scanFailed(self.rustBackend.lastError() ?? ZcashOperationError.unknown)
+                    return
+                }
+                let scanFinishTime = Date()
+                NotificationCenter.default.post(
+                    SDKMetrics.progressReportNotification(
+                        progress: BlockProgress(
+                            startHeight: self.blockRange.lowerBound,
+                            targetHeight: self.blockRange.upperBound,
+                            progressHeight: self.blockRange.upperBound
+                        ),
+                        start: scanStartTime,
+                        end: scanFinishTime,
+                        task: .scanBlocks
+                    )
+                )
+                let seconds = scanFinishTime.timeIntervalSinceReferenceDate - scanStartTime.timeIntervalSinceReferenceDate
+                LoggerProxy.debug("Scanned \(blockRange.count) blocks in \(seconds) seconds")
+            } else {
+                let scanStartHeight = try transactionRepository.lastScannedHeight()
+                let targetScanHeight = blockRange.upperBound
+
+                var scannedNewBlocks = false
+                var lastScannedHeight = scanStartHeight
+
+                repeat {
+                    guard !shouldCancel() else {
+                        cancel()
+                        return
+                    }
+                    let previousScannedHeight = lastScannedHeight
+                    let scanStartTime = Date()
+                    guard self.rustBackend.scanBlocks(
+                        dbCache: self.cacheDb,
+                        dbData: self.dataDb,
+                        limit: batchSize,
+                        networkType: network
+                    ) else {
+                        self.scanFailed(self.rustBackend.lastError() ?? ZcashOperationError.unknown)
+                        return
+                    }
+                    let scanFinishTime = Date()
+                    
+                    lastScannedHeight = try transactionRepository.lastScannedHeight()
+                    
+                    scannedNewBlocks = previousScannedHeight != lastScannedHeight
+                    if scannedNewBlocks {
+                        let progress = BlockProgress(startHeight: scanStartHeight, targetHeight: targetScanHeight, progressHeight: lastScannedHeight)
+                        progressDelegate?.progressUpdated(.scan(progress))
+                        NotificationCenter.default.post(
+                            SDKMetrics.progressReportNotification(
+                                progress: progress,
+                                start: scanStartTime,
+                                end: scanFinishTime,
+                                task: .scanBlocks
+                            )
+                        )
+
+                        let heightCount = lastScannedHeight - previousScannedHeight
+                        let seconds = scanFinishTime.timeIntervalSinceReferenceDate - scanStartTime.timeIntervalSinceReferenceDate
+                        LoggerProxy.debug("Scanned \(heightCount) blocks in \(seconds) seconds")
+                    }
+                } while !self.isCancelled && scannedNewBlocks && lastScannedHeight < targetScanHeight
+            }
+        } catch {
+            scanFailed(error)
+        }
+    }
+    
+    func scanFailed(_ error: Error) {
+        self.error = error
+        LoggerProxy.debug("block scanning failed with error: \(String(describing: self.error))")
+        self.fail()
+    }
+}

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

@@ -0,0 +1,66 @@
+//
+//  CompactBlockValidationInformation.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/30/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+enum CompactBlockValidationError: Error {
+    case validationFailed(height: BlockHeight)
+    case failedWithError(_ error: Error?)
+}
+class CompactBlockValidationOperation: ZcashOperation {
+    override var isConcurrent: Bool { false }
+    
+    override var isAsynchronous: Bool { false }
+    
+    var rustBackend: ZcashRustBackendWelding.Type
+    
+    private var cacheDb: URL
+    private var dataDb: URL
+    private var network: NetworkType
+    
+    init(
+        rustWelding: ZcashRustBackendWelding.Type,
+        cacheDb: URL,
+        dataDb: URL,
+        networkType: NetworkType
+    ) {
+        rustBackend = rustWelding
+        self.cacheDb = cacheDb
+        self.dataDb = dataDb
+        self.network = networkType
+        super.init()
+    }
+    
+    override func main() {
+        guard !shouldCancel() else {
+            cancel()
+            return
+        }
+
+        self.startedHandler?()
+
+        let result = self.rustBackend.validateCombinedChain(dbCache: cacheDb, dbData: dataDb, networkType: self.network)
+
+        switch result {
+        case 0:
+            let error = CompactBlockValidationError.failedWithError(rustBackend.lastError())
+            self.error = error
+            LoggerProxy.debug("block scanning failed with error: \(String(describing: self.error))")
+            self.fail(error: error)
+            
+        case ZcashRustBackendWeldingConstants.validChain:
+            break
+            
+        default:
+            let error = CompactBlockValidationError.validationFailed(height: BlockHeight(result))
+            self.error = error
+            LoggerProxy.debug("block scanning failed with error: \(String(describing: self.error))")
+            self.fail(error: error)
+        }
+    }
+}

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

@@ -0,0 +1,103 @@
+//
+//  FetchUnspentTxOutputsOperation.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 6/2/21.
+//
+
+import Foundation
+
+class FetchUnspentTxOutputsOperation: ZcashOperation {
+    enum FetchUTXOError: Error {
+        case clearingFailed(_ error: Error?)
+        case fetchFailed(error: Error)
+    }
+
+    override var isConcurrent: Bool { false }
+    override var isAsynchronous: Bool { false }
+    
+    var fetchedUTXOsHandler: ((RefreshedUTXOs) -> Void)?
+    
+    private var accountRepository: AccountRepository
+    private var downloader: CompactBlockDownloading
+    private var rustbackend: ZcashRustBackendWelding.Type
+    private var startHeight: BlockHeight
+    private var network: NetworkType
+    private var dataDb: URL
+    
+    init(
+        accountRepository: AccountRepository,
+        downloader: CompactBlockDownloading,
+        rustbackend: ZcashRustBackendWelding.Type,
+        dataDb: URL,
+        startHeight: BlockHeight,
+        networkType: NetworkType
+    ) {
+        self.dataDb = dataDb
+        self.accountRepository = accountRepository
+        self.downloader = downloader
+        self.rustbackend = rustbackend
+        self.startHeight = startHeight
+        self.network = networkType
+    }
+    
+    override func main() {
+        guard !shouldCancel() else {
+            cancel()
+            return
+        }
+
+        self.startedHandler?()
+
+        do {
+            let tAddresses = try accountRepository.getAll().map({ $0.transparentAddress })
+            do {
+                for tAddress in tAddresses {
+                    guard try self.rustbackend.clearUtxos(
+                        dbData: dataDb,
+                        address: tAddress,
+                        sinceHeight: startHeight - 1,
+                        networkType: network
+                    ) >= 0 else {
+                        throw rustbackend.lastError() ?? RustWeldingError.genericError(message: "attempted to clear utxos but -1 was returned")
+                    }
+                }
+            } catch {
+                throw FetchUTXOError.clearingFailed(error)
+            }
+            
+            let utxos = try downloader.fetchUnspentTransactionOutputs(tAddresses: tAddresses, startHeight: startHeight)
+            
+            let result = storeUTXOs(utxos, in: dataDb)
+            
+            self.fetchedUTXOsHandler?(result)
+        } catch {
+            self.fail(error: error)
+        }
+    }
+    
+    private func storeUTXOs(_ utxos: [UnspentTransactionOutputEntity], in dataDb: URL) -> RefreshedUTXOs {
+        var refreshed: [UnspentTransactionOutputEntity] = []
+        var skipped: [UnspentTransactionOutputEntity] = []
+
+        for utxo in utxos {
+            do {
+                try self.rustbackend.putUnspentTransparentOutput(
+                    dbData: dataDb,
+                    address: utxo.address,
+                    txid: utxo.txid.bytes,
+                    index: utxo.index,
+                    script: utxo.script.bytes,
+                    value: Int64(utxo.valueZat),
+                    height: utxo.height,
+                    networkType: network
+                ) ? refreshed.append(utxo) : skipped.append(utxo)
+            } catch {
+                LoggerProxy.error("failed to put utxo - error: \(error)")
+                skipped.append(utxo)
+            }
+        }
+
+        return (inserted: refreshed, skipped: skipped)
+    }
+}

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

@@ -0,0 +1,58 @@
+//
+//  FigureNextBatchOperation.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 6/17/21.
+//
+
+import Foundation
+
+class FigureNextBatchOperation: ZcashOperation {
+    enum NextState {
+        case finishProcessing(height: BlockHeight)
+        case processNewBlocks(range: CompactBlockRange)
+        case wait(latestHeight: BlockHeight, latestDownloadHeight: BlockHeight)
+    }
+    
+    private var service: LightWalletService
+    private var downloader: CompactBlockDownloading
+    private var config: CompactBlockProcessor.Configuration
+    private var rustBackend: ZcashRustBackendWelding.Type
+    private(set) var result: NextState?
+
+    required init(
+        downloader: CompactBlockDownloading,
+        service: LightWalletService,
+        config: CompactBlockProcessor.Configuration,
+        rustBackend: ZcashRustBackendWelding.Type
+    ) {
+        self.service = service
+        self.config = config
+        self.downloader = downloader
+        self.rustBackend = rustBackend
+
+        super.init()
+
+        self.name = "Next Batch Operation"
+    }
+    
+    override func main() {
+        guard !shouldCancel() else {
+            cancel()
+            return
+        }
+
+        self.startedHandler?()
+        
+        do {
+            result = try CompactBlockProcessor.NextStateHelper.nextState(
+                service: self.service,
+                downloader: self.downloader,
+                config: self.config,
+                rustBackend: self.rustBackend
+            )
+        } catch {
+            self.fail(error: error)
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+//
+//  ZcashOperation.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/27/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+typealias ZcashOperationCompletionBlock = (_ finished: Bool, _ cancelled: Bool) -> Void
+typealias ZcashOperationStartedBlock = () -> Void
+typealias ZcashOperationErrorBlock = (_ error: Error) -> Void
+
+enum ZcashOperationError: Error {
+    case unknown
+}
+
+class ZcashOperation: Operation {
+    var error: Error?
+    var startedHandler: ZcashOperationStartedBlock?
+    var errorHandler: ZcashOperationErrorBlock?
+    var completionHandler: ZcashOperationCompletionBlock?
+    var handlerDispatchQueue = DispatchQueue.main
+    
+    override init() {
+        super.init()
+        
+        completionBlock = { [weak self] in
+            guard let self = self, let handler = self.completionHandler else { return }
+            
+            handler(self.isFinished, self.isCancelled)
+        }
+    }
+    
+    convenience init(completionDispatchQueue: DispatchQueue = DispatchQueue.main) {
+        self.init()
+        self.handlerDispatchQueue = completionDispatchQueue
+    }
+
+    func shouldCancel() -> Bool {
+        self.error != nil || isCancelled || dependencyCancelled()
+    }
+    
+    func dependencyCancelled() -> Bool {
+        self.dependencies.first { $0.isCancelled } != nil
+    }
+    
+    func fail(error: Error? = nil) {
+        defer {
+            self.cancel()
+        }
+        
+        if let error = error {
+            self.error = error
+        }
+        LoggerProxy.debug("\(self) failed")
+        
+        guard let errorHandler = self.errorHandler else {
+            return
+        }
+        
+        self.handlerDispatchQueue.async { [weak self] in
+            let error = error ?? (self?.error ?? ZcashOperationError.unknown)
+            errorHandler(error)
+        }
+    }
+}

package/ios/ZCashLightClientKit/Constants/WalletBirthday+Constants.swift

@@ -0,0 +1,58 @@
+//
+//  WalletBirthday+Constants.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 7/28/21.
+//
+
+import Foundation
+
+public extension WalletBirthday {
+  static func birthday(with height: BlockHeight, network: ZcashNetwork) -> WalletBirthday {
+    switch network.networkType {
+    case .mainnet:
+      return birthday(with: height, checkpointDirectory: Self.mainnetCheckpointDirectory) ?? .mainnetMin
+    case .testnet:
+      return birthday(with: height, checkpointDirectory: Self.testnetCheckpointDirectory) ?? .testnetMin
+    }
+  }
+}
+
+extension WalletBirthday {
+  static func birthday(with height: BlockHeight, checkpointDirectory: URL) -> WalletBirthday? {
+    return bestCheckpointHeight(for: height, checkpointDirectory: checkpointDirectory)
+      .flatMap { checkpoint(height: $0, directory: checkpointDirectory) }
+  }
+
+  private static func bestCheckpointHeight(for height: BlockHeight, checkpointDirectory: URL) -> Int? {
+    guard let checkPointURLs = try? FileManager.default.contentsOfDirectory(
+      at: checkpointDirectory,
+      includingPropertiesForKeys: nil,
+      options: .skipsHiddenFiles
+    ) else {
+      return nil
+    }
+
+    return checkPointURLs
+      .map { $0.deletingPathExtension() }
+      .map(\.lastPathComponent)
+      .compactMap(Int.init)
+      .filter { $0 <= height }
+      .sorted()
+      .last
+  }
+
+  private static func checkpoint(height: BlockHeight, directory checkpointDirectory: URL) -> WalletBirthday? {
+    let url = checkpointDirectory
+      .appendingPathComponent(String(height))
+      .appendingPathExtension("json")
+
+    return try? checkpoint(at: url)
+  }
+
+  private static func checkpoint(at url: URL) throws -> WalletBirthday {
+    let data = try Data(contentsOf: url)
+    let checkpoint = try JSONDecoder().decode(WalletBirthday.self, from: data)
+    return checkpoint
+  }
+}

package/ios/ZCashLightClientKit/Constants/WalletBirthday+mainnet.swift

@@ -0,0 +1,20 @@
+//
+//  WalletBirthday+mainnet.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 7/28/21.
+//
+// swiftlint:disable function_body_length line_length cyclomatic_complexity
+import Foundation
+
+extension WalletBirthday {
+  static let mainnetMin = WalletBirthday(
+    height: 419_200,
+    hash: "00000000025a57200d898ac7f21e26bf29028bbe96ec46e05b2c17cc9db9e4f3",
+    time: 1540779337,
+    tree: "000000"
+  )
+
+  static let mainnetCheckpointDirectory = Bundle.main.url(forResource: "zcash-mainnet", withExtension: "bundle")!
+
+}

package/ios/ZCashLightClientKit/Constants/WalletBirthday+testnet.swift

@@ -0,0 +1,20 @@
+//
+//  WalletBirthday+testnet.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 7/28/21.
+//
+// swiftlint:disable line_length cyclomatic_complexity function_body_length
+import Foundation
+
+extension WalletBirthday {
+  static let testnetMin = WalletBirthday(
+    height: 280000,
+    hash: "000420e7fcc3a49d729479fb0b560dd7b8617b178a08e9e389620a9d1dd6361a",
+    time: 1535262293,
+    tree: "000000"
+  )
+  
+  static let testnetCheckpointDirectory = Bundle.main.url(forResource: "zcash-testnet", withExtension: "bundle")!
+  
+}