react-native-zcash 0.3.5 → 0.4.1

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

@@ -1,238 +0,0 @@
-//
-//  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

@@ -1,66 +0,0 @@
-//
-//  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

@@ -1,103 +0,0 @@
-//
-//  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

@@ -1,58 +0,0 @@
-//
-//  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

@@ -1,68 +0,0 @@
-//
-//  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

@@ -1,58 +0,0 @@
-//
-//  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

@@ -1,20 +0,0 @@
-//
-//  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

@@ -1,20 +0,0 @@
-//
-//  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")!
-  
-}

package/ios/ZCashLightClientKit/DAO/CompactBlockDAO.swift

@@ -1,24 +0,0 @@
-//
-//   CompactBlockDAO.swift
-//  ZcashLightClientKit
-//
-//  Created by Francisco Gindre on 10/16/19.
-//  Copyright © 2019 Electric Coin Company. All rights reserved.
-//
-
-import Foundation
-
-protocol CompactBlockDAO {
-    func createTable() throws
-    
-    func insert(_ block: ZcashCompactBlock) throws
-    
-    func insert(_ blocks: [ZcashCompactBlock]) throws
-    
-    /**
-    Query the latest block height, returns -1 if no block is stored
-    */
-    func latestBlockHeight() throws -> BlockHeight
-    
-    func rewind(to height: BlockHeight) throws
-}