react-native-zcash 0.3.5 → 0.4.0

package/ios/ZCashLightClientKit/Service/LightWalletGRPCService.swift

@@ -1,551 +0,0 @@
-//
-//  ServiceHelper.swift
-//  gRPC-PoC
-//
-//  Created by Francisco Gindre on 29/08/2019.
-//  Copyright © 2019 Electric Coin Company. All rights reserved.
-//
-
-import Foundation
-import GRPC
-import NIO
-import NIOHPACK
-
-public typealias Channel = GRPC.GRPCChannel
-
-public protocol LightWalletdInfo {
-    var version: String { get }
-
-    var vendor: String { get }
-
-    /// true
-    var taddrSupport: Bool { get }
-
-    /// either "main" or "test"
-    var chainName: String { get }
-
-    /// depends on mainnet or testnet
-    var saplingActivationHeight: UInt64 { get }
-
-    /// protocol identifier, see consensus/upgrades.cpp
-    var consensusBranchID: String { get }
-
-    /// latest block on the best chain
-    var blockHeight: UInt64 { get }
-
-    var gitCommit: String { get }
-
-    var branch: String { get }
-
-    var buildDate: String { get }
-
-    var buildUser: String { get }
-
-    /// less than tip height if zcashd is syncing
-    var estimatedHeight: UInt64 { get }
-
-    /// example: "v4.1.1-877212414"
-    var zcashdBuild: String { get }
-
-    /// example: "/MagicBean:4.1.1/"
-    var zcashdSubversion: String { get }
-}
-
-extension LightdInfo: LightWalletdInfo {}
-
-/**
-Swift GRPC implementation of Lightwalletd service
-*/
-public enum GRPCResult: Equatable {
-    case success
-    case error(_ error: LightWalletServiceError)
-}
-
-public protocol CancellableCall {
-    func cancel()
-}
-
-extension ServerStreamingCall: CancellableCall {
-    public func cancel() {
-        self.cancel(promise: self.eventLoop.makePromise(of: Void.self))
-    }
-}
-
-public struct BlockProgress: Equatable {
-    public var startHeight: BlockHeight
-    public var targetHeight: BlockHeight
-    public var progressHeight: BlockHeight
-
-    public var progress: Float {
-        let overall = self.targetHeight - self.startHeight
-
-        return overall > 0 ? Float((self.progressHeight - self.startHeight)) / Float(overall) : 0
-    }
-}
-
-public extension BlockProgress {
-    static let nullProgress = BlockProgress(startHeight: 0, targetHeight: 0, progressHeight: 0)
-}
-
-public class LightWalletGRPCService {
-    let channel: Channel
-    let connectionManager: ConnectionStatusManager
-    let compactTxStreamer: CompactTxStreamerClient
-    let singleCallTimeout: TimeLimit
-    let streamingCallTimeout: TimeLimit
-
-    var queue: DispatchQueue
-    
-    public convenience init(endpoint: LightWalletEndpoint) {
-        self.init(
-            host: endpoint.host,
-            port: endpoint.port,
-            secure: endpoint.secure,
-            singleCallTimeout: endpoint.singleCallTimeoutInMillis,
-            streamingCallTimeout: endpoint.streamingCallTimeoutInMillis
-        )
-    }
-
-    public init(host: String, port: Int = 9067, secure: Bool = true, singleCallTimeout: Int64 = 10000, streamingCallTimeout: Int64 = 10000) {
-        self.connectionManager = ConnectionStatusManager()
-        self.queue = DispatchQueue.init(label: "LightWalletGRPCService")
-        self.streamingCallTimeout = TimeLimit.timeout(.milliseconds(streamingCallTimeout))
-        self.singleCallTimeout = TimeLimit.timeout(.milliseconds(singleCallTimeout))
-
-        let configuration = ClientConnection.Configuration(
-            target: .hostAndPort(host, port),
-            eventLoopGroup: MultiThreadedEventLoopGroup(numberOfThreads: 1),
-            connectivityStateDelegate: connectionManager,
-            connectivityStateDelegateQueue: queue,
-            tls: secure ? .init() : nil
-        )
-        let channel = ClientConnection(configuration: configuration)
-
-        self.channel = channel
-
-        compactTxStreamer = CompactTxStreamerClient(
-            channel: self.channel,
-            defaultCallOptions: Self.callOptions(
-                timeLimit: TimeLimit.timeout(.seconds(Int64(singleCallTimeout)))
-            )
-        )
-    }
-
-    deinit {
-        _ = channel.close()
-        _ = compactTxStreamer.channel.close()
-    }
-
-    func stop() {
-        _ = channel.close()
-    }
-    
-    func blockRange(startHeight: BlockHeight, endHeight: BlockHeight? = nil, result: @escaping (CompactBlock) -> Void) throws -> ServerStreamingCall<BlockRange, CompactBlock> {
-        compactTxStreamer.getBlockRange(BlockRange(startHeight: startHeight, endHeight: endHeight), handler: result)
-    }
-    
-    func latestBlock() throws -> BlockID {
-        try compactTxStreamer.getLatestBlock(ChainSpec()).response.wait()
-    }
-    
-    func getTx(hash: String) throws -> RawTransaction {
-        var filter = TxFilter()
-        filter.hash = Data(hash.utf8)
-
-        return try compactTxStreamer.getTransaction(filter).response.wait()
-    }
-    
-    static func callOptions(timeLimit: TimeLimit) -> CallOptions {
-        CallOptions(
-            customMetadata: HPACKHeaders(),
-            timeLimit: timeLimit,
-            messageEncoding: .disabled,
-            requestIDProvider: .autogenerated,
-            requestIDHeader: nil,
-            cacheable: false
-        )
-    }
-}
-
-extension LightWalletGRPCService: LightWalletService {
-    @discardableResult
-    public func blockStream(
-        startHeight: BlockHeight,
-        endHeight: BlockHeight,
-        result: @escaping (Result<GRPCResult, LightWalletServiceError>) -> Void,
-        handler: @escaping (ZcashCompactBlock) -> Void,
-        progress: @escaping  (BlockProgress) -> Void
-    ) -> CancellableCall {
-        let future = compactTxStreamer.getBlockRange(
-            BlockRange(
-                startHeight: startHeight,
-                endHeight: endHeight
-            ),
-            callOptions: Self.callOptions(timeLimit: self.streamingCallTimeout),
-            handler: { compactBlock in
-                handler(ZcashCompactBlock(compactBlock: compactBlock))
-                progress(
-                    BlockProgress(
-                        startHeight: startHeight,
-                        targetHeight: endHeight,
-                        progressHeight: BlockHeight(compactBlock.height)
-                    )
-                )
-            }
-        )
-        
-        future.status.whenComplete { completionResult in
-            switch completionResult {
-            case .success(let status):
-                switch status.code {
-                case .ok:
-                    result(.success(GRPCResult.success))
-                default:
-                    result(.failure(LightWalletServiceError.mapCode(status)))
-                }
-            case .failure(let error):
-                result(.failure(LightWalletServiceError.genericError(error: error)))
-            }
-        }
-        return future
-    }
-     
-    public func getInfo() throws -> LightWalletdInfo {
-        try compactTxStreamer.getLightdInfo(Empty()).response.wait()
-    }
-    
-    public func getInfo(result: @escaping (Result<LightWalletdInfo, LightWalletServiceError>) -> Void) {
-        compactTxStreamer.getLightdInfo(Empty()).response.whenComplete { completionResult in
-            switch completionResult {
-            case .success(let info):
-                result(.success(info))
-            case .failure(let error):
-                result(.failure(error.mapToServiceError()))
-            }
-        }
-    }
-    
-    public func closeConnection() {
-        _ = channel.close()
-    }
-    
-    public func fetchTransaction(txId: Data) throws -> TransactionEntity {
-        var txFilter = TxFilter()
-        txFilter.hash = txId
-        
-        do {
-            let rawTx = try compactTxStreamer.getTransaction(txFilter).response.wait()
-            
-            return TransactionBuilder.createTransactionEntity(txId: txId, rawTransaction: rawTx)
-        } catch {
-            throw error.mapToServiceError()
-        }
-    }
-    
-    public func fetchTransaction(txId: Data, result: @escaping (Result<TransactionEntity, LightWalletServiceError>) -> Void) {
-        var txFilter = TxFilter()
-        txFilter.hash = txId
-        
-        compactTxStreamer.getTransaction(txFilter).response.whenComplete { response in
-            switch response {
-            case .failure(let error):
-                result(.failure(error.mapToServiceError()))
-            case .success(let rawTx):
-                result(.success(TransactionBuilder.createTransactionEntity(txId: txId, rawTransaction: rawTx)))
-            }
-        }
-    }
-    
-    public func submit(spendTransaction: Data, result: @escaping (Result<LightWalletServiceResponse, LightWalletServiceError>) -> Void) {
-        do {
-            let transaction = try RawTransaction(serializedData: spendTransaction)
-            let response = self.compactTxStreamer.sendTransaction(transaction).response
-            
-            response.whenComplete { responseResult in
-                switch responseResult {
-                case .failure(let error):
-                    result(.failure(LightWalletServiceError.sentFailed(error: error)))
-                case .success(let success):
-                    result(.success(success))
-                }
-            }
-        } catch {
-            result(.failure(error.mapToServiceError()))
-        }
-    }
-    
-    public func submit(spendTransaction: Data) throws -> LightWalletServiceResponse {
-        let rawTx = RawTransaction.with { raw in
-            raw.data = spendTransaction
-        }
-        do {
-            return try compactTxStreamer.sendTransaction(rawTx).response.wait()
-        } catch {
-            throw error.mapToServiceError()
-        }
-    }
-    
-    public func blockRange(_ range: CompactBlockRange) throws -> [ZcashCompactBlock] {
-        var blocks: [CompactBlock] = []
-        
-        let response = compactTxStreamer.getBlockRange(
-            range.blockRange(),
-            handler: { blocks.append($0) }
-        )
-        
-        let status = try response.status.wait()
-
-        switch status.code {
-        case .ok:
-            return blocks.asZcashCompactBlocks()
-        default:
-            throw LightWalletServiceError.mapCode(status)
-        }
-    }
-    
-    public func latestBlockHeight(result: @escaping (Result<BlockHeight, LightWalletServiceError>) -> Void) {
-        let response = compactTxStreamer.getLatestBlock(ChainSpec()).response
-        
-        response.whenSuccessBlocking(onto: queue) { blockID in
-            guard let blockHeight = Int(exactly: blockID.height) else {
-                result(.failure(LightWalletServiceError.generalError(message: "error creating blockheight from BlockID \(blockID)")))
-                return
-            }
-            result(.success(blockHeight))
-        }
-        
-        response.whenFailureBlocking(onto: queue) { error in
-            result(.failure(error.mapToServiceError()))
-        }
-    }
-    
-    public func blockRange(_ range: CompactBlockRange, result: @escaping (Result<[ZcashCompactBlock], LightWalletServiceError>) -> Void) {
-        queue.async { [weak self] in
-            guard let self = self else { return }
-
-            var blocks: [CompactBlock] = []
-            let response = self.compactTxStreamer.getBlockRange(range.blockRange(), handler: { blocks.append($0) })
-
-            do {
-                let status = try response.status.wait()
-                switch status.code {
-                case .ok:
-                    result(.success(blocks.asZcashCompactBlocks()))
-                    
-                default:
-                    result(.failure(.mapCode(status)))
-                }
-            } catch {
-                result(.failure(error.mapToServiceError()))
-            }
-        }
-    }
-    
-    public func latestBlockHeight() throws -> BlockHeight {
-        guard let height = try? latestBlock().compactBlockHeight() else {
-            throw LightWalletServiceError.invalidBlock
-        }
-        return height
-    }
-    
-    public func fetchUTXOs(for tAddress: String, height: BlockHeight) throws -> [UnspentTransactionOutputEntity] {
-        let arg = GetAddressUtxosArg.with { utxoArgs in
-            utxoArgs.addresses = [tAddress]
-            utxoArgs.startHeight = UInt64(height)
-        }
-        do {
-            return try self.compactTxStreamer.getAddressUtxos(arg).response.wait().addressUtxos.map { reply in
-                UTXO(
-                    id: nil,
-                    address: tAddress,
-                    prevoutTxId: reply.txid,
-                    prevoutIndex: Int(reply.index),
-                    script: reply.script,
-                    valueZat: Int(reply.valueZat),
-                    height: Int(reply.height),
-                    spentInTx: nil
-                )
-            }
-        } catch {
-            throw error.mapToServiceError()
-        }
-    }
-    
-    public func fetchUTXOs(for tAddress: String, height: BlockHeight, result: @escaping (Result<[UnspentTransactionOutputEntity], LightWalletServiceError>) -> Void) {
-        queue.async { [weak self] in
-            guard let self = self else { return }
-            let arg = GetAddressUtxosArg.with { utxoArgs in
-                utxoArgs.addresses = [tAddress]
-                utxoArgs.startHeight = UInt64(height)
-            }
-            var utxos: [UnspentTransactionOutputEntity] = []
-            let response = self.compactTxStreamer.getAddressUtxosStream(arg) { reply in
-                utxos.append(
-                    UTXO(
-                        id: nil,
-                        address: tAddress,
-                        prevoutTxId: reply.txid,
-                        prevoutIndex: Int(reply.index),
-                        script: reply.script,
-                        valueZat: Int(reply.valueZat),
-                        height: Int(reply.height),
-                        spentInTx: nil
-                    )
-                )
-            }
-            
-            do {
-                let status = try response.status.wait()
-                switch status.code {
-                case .ok:
-                    result(.success(utxos))
-                default:
-                    result(.failure(.mapCode(status)))
-                }
-            } catch {
-                result(.failure(error.mapToServiceError()))
-            }
-        }
-    }
-    
-    public func fetchUTXOs(for tAddresses: [String], height: BlockHeight) throws -> [UnspentTransactionOutputEntity] {
-        guard !tAddresses.isEmpty else {
-            return [] // FIXME: throw a real error
-        }
-        
-        var utxos: [UnspentTransactionOutputEntity] = []
-        
-        let arg = GetAddressUtxosArg.with { utxoArgs in
-            utxoArgs.addresses = tAddresses
-            utxoArgs.startHeight = UInt64(height)
-        }
-        utxos.append(
-            contentsOf:
-            try self.compactTxStreamer.getAddressUtxos(arg).response.wait().addressUtxos.map { reply in
-            UTXO(
-                id: nil,
-                address: reply.address,
-                prevoutTxId: reply.txid,
-                prevoutIndex: Int(reply.index),
-                script: reply.script,
-                valueZat: Int(reply.valueZat),
-                height: Int(reply.height),
-                spentInTx: nil
-                )
-            }
-        )
-       
-        return utxos
-    }
-    
-    public func fetchUTXOs(
-        for tAddresses: [String],
-        height: BlockHeight,
-        result: @escaping (Result<[UnspentTransactionOutputEntity], LightWalletServiceError>) -> Void
-    ) {
-        guard !tAddresses.isEmpty else {
-            return result(.success([])) // FIXME: throw a real error
-        }
-        
-        var utxos: [UnspentTransactionOutputEntity] = []
-        self.queue.async { [weak self] in
-            guard let self = self else { return }
-            let args = GetAddressUtxosArg.with { utxoArgs in
-                utxoArgs.addresses = tAddresses
-                utxoArgs.startHeight = UInt64(height)
-            }
-            do {
-                let response = try self.compactTxStreamer.getAddressUtxosStream(args) { reply in
-                    utxos.append(
-                        UTXO(
-                            id: nil,
-                            address: reply.address,
-                            prevoutTxId: reply.txid,
-                            prevoutIndex: Int(reply.index),
-                            script: reply.script,
-                            valueZat: Int(reply.valueZat),
-                            height: Int(reply.height),
-                            spentInTx: nil
-                        )
-                    )
-                }
-                .status
-                .wait()
-
-                switch response.code {
-                case .ok:
-                    result(.success(utxos))
-                default:
-                    result(.failure(.mapCode(response)))
-                }
-            } catch {
-                result(.failure(error.mapToServiceError()))
-            }
-        }
-    }
-}
-
-// MARK: - Extensions
-
-extension Notification.Name {
-    static let connectionStatusChanged = Notification.Name("LightWalletServiceConnectivityStatusChanged")
-}
-
-extension TimeAmount {
-    static let singleCallTimeout = TimeAmount.seconds(30)
-    static let streamingCallTimeout = TimeAmount.minutes(10)
-}
-
-extension CallOptions {
-    static var lwdCall: CallOptions {
-        CallOptions(
-            customMetadata: HPACKHeaders(),
-            timeLimit: .timeout(.singleCallTimeout),
-            messageEncoding: .disabled,
-            requestIDProvider: .autogenerated,
-            requestIDHeader: nil,
-            cacheable: false
-        )
-    }
-}
-
-extension Error {
-    func mapToServiceError() -> LightWalletServiceError {
-        guard let grpcError = self as? GRPCStatusTransformable else {
-            return LightWalletServiceError.genericError(error: self)
-        }
-        
-        return LightWalletServiceError.mapCode(grpcError.makeGRPCStatus())
-    }
-}
-
-extension LightWalletServiceError {
-    static func mapCode(_ status: GRPCStatus) -> LightWalletServiceError {
-        switch status.code {
-        case .ok:
-            return LightWalletServiceError.unknown
-        case .cancelled:
-            return LightWalletServiceError.userCancelled
-        case .unknown:
-            return LightWalletServiceError.generalError(message: status.message ?? "GRPC unknown error contains no message")
-        case .deadlineExceeded:
-            return LightWalletServiceError.timeOut
-        default:
-            return LightWalletServiceError.genericError(error: status)
-        }
-    }
-}
-
-class ConnectionStatusManager: ConnectivityStateDelegate {
-    func connectivityStateDidChange(from oldState: ConnectivityState, to newState: ConnectivityState) {
-        LoggerProxy.event("Connection Changed from \(oldState) to \(newState)")
-        NotificationCenter.default.post(
-            name: .blockProcessorConnectivityStateChanged,
-            object: self,
-            userInfo: [
-                CompactBlockProcessorNotificationKey.currentConnectivityStatus: newState,
-                CompactBlockProcessorNotificationKey.previousConnectivityStatus: oldState
-            ]
-        )
-    }
-}