react-native-zcash 0.3.4 → 0.3.5

package/ios/ZCashLightClientKit/Block/DatabaseStorage/StorageManager.swift

@@ -0,0 +1,73 @@
+//
+//  SQLDatabase.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/13/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+import SQLite
+
+class StorageManager {
+    static var shared = StorageManager()
+    
+    private var readOnly: [URL: Connection] = [:]
+    private var readWrite: [URL: Connection] = [:]
+    
+    init() {}
+    
+    func connection(at url: URL, readOnly: Bool = false) throws -> Connection {
+        readOnly ? try readOnlyConnection(at: url) : try readWriteConnection(at: url)
+    }
+    
+    private func readOnlyConnection(at url: URL) throws -> Connection {
+        if let readOnlyConnection = readOnly[url] {
+            return readOnlyConnection
+        }
+        
+        let readOnlyConnection = try Connection.customConection(at: url)
+        readOnly[url] = readOnlyConnection
+
+        return readOnlyConnection
+    }
+    
+    private func readWriteConnection(at url: URL) throws -> Connection {
+        if let readWriteConnection = readWrite[url] {
+            return readWriteConnection
+        }
+        
+        let readWriteConnection = try Connection.customConection(at: url)
+        readWrite[url] = readWriteConnection
+
+        return readWriteConnection
+    }
+}
+
+private extension Connection {
+    static func customConection(at url: URL, readonly: Bool = false) throws -> Connection {
+        let conn = try Connection(url.absoluteString, readonly: readonly)
+        try conn.run("PRAGMA journal_mode = TRUNCATE;")
+        return conn
+    }
+}
+
+class SimpleConnectionProvider: ConnectionProvider {
+    var path: String
+    var readonly: Bool
+    var db: Connection?
+    
+    init(path: String, readonly: Bool = false) {
+        self.path = path
+        self.readonly = readonly
+    }
+
+    func connection() throws -> Connection {
+        guard let conn = db else {
+            let conn = try Connection(path, readonly: readonly)
+            self.db = conn
+            return conn
+        }
+        return conn
+    }
+}

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

@@ -0,0 +1,240 @@
+//
+//  BlockDownloader.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 17/09/2019.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+enum CompactBlockDownloadError: Error {
+    case timeout
+    case generalError(error: Error)
+}
+/**
+Represents what a compact block downloaded should provide to its clients
+*/
+public protocol CompactBlockDownloading {
+    /**
+    Downloads and stores the given block range.
+    Non-Blocking
+    */
+    func downloadBlockRange(
+        _ heightRange: CompactBlockRange,
+        completion: @escaping (Error?) -> Void
+    )
+    
+    /**
+    Remove newer blocks and go back to the given height
+    - Parameters:
+        - height: the given height to rewind to
+        - completion: block to be executed after completing rewind
+    */
+    func rewind(to height: BlockHeight, completion: @escaping (Error?) -> Void)
+    
+    /**
+    returns the height of the latest compact block stored locally
+    BlockHeight.empty() if no blocks are stored yet
+    non-blocking
+    */
+    func lastDownloadedBlockHeight(result: @escaping (Result<BlockHeight, Error>) -> Void)
+    
+    /**
+    Returns the last height on the blockchain
+    Non-blocking
+    */
+    func latestBlockHeight(result: @escaping (Result<BlockHeight, Error>) -> Void)
+    
+    /**
+    Downloads and stores the given block range.
+    Blocking
+    */
+    func downloadBlockRange(_ range: CompactBlockRange) throws
+    
+    /**
+    Restore the download progress up to the given height.
+    */
+    func rewind(to height: BlockHeight) throws
+
+    /**
+    Returns the height of the latest compact block stored locally.
+    BlockHeight.empty() if no blocks are stored yet
+    Blocking
+    */
+    func lastDownloadedBlockHeight() throws -> BlockHeight
+    
+    /**
+    Returns the latest block height
+    Blocking
+    */
+    func latestBlockHeight() throws -> BlockHeight
+    
+    /**
+    Gets the transaction for the Id given
+    - Parameter txId: Data representing the transaction Id
+    - Returns: a transaction entity with the requested transaction
+    - Throws: An error if the fetch failed
+    */
+    func fetchTransaction(txId: Data) throws -> TransactionEntity
+    
+    /**
+    Gets the transaction for the Id given
+    - Parameter txId: Data representing the transaction Id
+    - Parameter result: a handler for the result of the operation
+    */
+    func fetchTransaction(txId: Data, result: @escaping (Result<TransactionEntity, Error>) -> Void)
+    
+    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight) throws -> [UnspentTransactionOutputEntity]
+    
+    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight, result: @escaping (Result<[UnspentTransactionOutputEntity], Error>) -> Void)
+    
+    func fetchUnspentTransactionOutputs(tAddresses: [String], startHeight: BlockHeight) throws -> [UnspentTransactionOutputEntity]
+    
+    func fetchUnspentTransactionOutputs(tAddresses: [String], startHeight: BlockHeight, result: @escaping (Result<[UnspentTransactionOutputEntity], Error>) -> Void)
+    
+    func closeConnection()
+}
+
+/**
+Serves as a source of compact blocks received from the light wallet server. Once started, it will use the given
+lightwallet service to request all the appropriate blocks and compact block store to persist them. By delegating to
+these dependencies, the downloader remains agnostic to the particular implementation of how to retrieve and store
+data; although, by default the SDK uses gRPC and SQL.
+- Property lightwalletService: the service used for requesting compact blocks
+- Property storage: responsible for persisting the compact blocks that are received
+*/
+class CompactBlockDownloader {
+    var lightwalletService: LightWalletService
+    private(set) var storage: CompactBlockRepository
+    
+    init(service: LightWalletService, storage: CompactBlockRepository) {
+        self.lightwalletService = service
+        self.storage = storage
+    }
+}
+
+extension CompactBlockDownloader: CompactBlockDownloading {
+    func closeConnection() {
+        lightwalletService.closeConnection()
+    }
+    
+    func fetchUnspentTransactionOutputs(tAddresses: [String], startHeight: BlockHeight) throws -> [UnspentTransactionOutputEntity] {
+        try lightwalletService.fetchUTXOs(for: tAddresses, height: startHeight)
+    }
+    
+    func fetchUnspentTransactionOutputs(
+        tAddresses: [String],
+        startHeight: BlockHeight,
+        result: @escaping (Result<[UnspentTransactionOutputEntity], Error>) -> Void
+    ) {
+        lightwalletService.fetchUTXOs(for: tAddresses, height: startHeight) { fetchResult in
+            switch fetchResult {
+            case .success(let utxos):
+                result(.success(utxos))
+            case .failure(let error):
+                result(.failure(error))
+            }
+        }
+    }
+    
+    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight) throws -> [UnspentTransactionOutputEntity] {
+        try lightwalletService.fetchUTXOs(for: tAddress, height: startHeight)
+    }
+    
+    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight, result: @escaping (Result<[UnspentTransactionOutputEntity], Error>) -> Void) {
+        lightwalletService.fetchUTXOs(for: tAddress, height: startHeight) { fetchResult in
+            switch fetchResult {
+            case .success(let utxos):
+                result(.success(utxos))
+            case .failure(let error):
+                result(.failure(error))
+            }
+        }
+    }
+    
+    func latestBlockHeight(result: @escaping (Result<BlockHeight, Error>) -> Void) {
+        lightwalletService.latestBlockHeight { fetchResult in
+            switch fetchResult {
+            case .failure(let error):
+                result(.failure(error))
+            case .success(let height):
+                result(.success(height))
+            }
+        }
+    }
+    
+    func latestBlockHeight() throws -> BlockHeight {
+        try lightwalletService.latestBlockHeight()
+    }
+    
+    /**
+    Downloads and stores the given block range.
+    Non-Blocking
+    */
+    func downloadBlockRange(
+        _ heightRange: CompactBlockRange,
+        completion: @escaping (Error?) -> Void
+    ) {
+        lightwalletService.blockRange(heightRange) { [weak self] result in
+            guard let self = self else {
+                return
+            }
+            
+            switch result {
+            case .failure(let error):
+                completion(error)
+            case .success(let compactBlocks):
+                self.storage.write(blocks: compactBlocks) { storeError in
+                    completion(storeError)
+                }
+            }
+        }
+    }
+    
+    func downloadBlockRange(_ range: CompactBlockRange) throws {
+        let blocks = try lightwalletService.blockRange(range)
+        try storage.write(blocks: blocks)
+    }
+    
+    func rewind(to height: BlockHeight, completion: @escaping (Error?) -> Void) {
+        storage.rewind(to: height) { e in
+            completion(e)
+        }
+    }
+    
+    func lastDownloadedBlockHeight(result: @escaping (Result<BlockHeight, Error>) -> Void) {
+        storage.latestHeight { heightResult in
+            switch heightResult {
+            case .failure(let e):
+                result(.failure(CompactBlockDownloadError.generalError(error: e)))
+                return
+            case .success(let height):
+                result(.success(height))
+            }
+        }
+    }
+    
+    func rewind(to height: BlockHeight) throws {
+        try self.storage.rewind(to: height)
+    }
+    
+    func lastDownloadedBlockHeight() throws -> BlockHeight {
+        try self.storage.latestHeight()
+    }
+    
+    func fetchTransaction(txId: Data) throws -> TransactionEntity {
+        try lightwalletService.fetchTransaction(txId: txId)
+    }
+    
+    func fetchTransaction(txId: Data, result: @escaping (Result<TransactionEntity, Error>) -> Void) {
+        lightwalletService.fetchTransaction(txId: txId) { txResult in
+            switch txResult {
+            case .failure(let error):
+                result(.failure(error))
+            case .success(let transaction):
+                result(.success(transaction))
+            }
+        }
+    }
+}

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)))
+    }
+}