react-native-zcash 0.3.5 → 0.4.0

package/ios/ZCashLightClientKit/Modules/Service/GRPC/LightWalletGRPCService.swift

@@ -0,0 +1,342 @@
+//
+//  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
+import NIOTransportServices
+
+typealias Channel = GRPC.GRPCChannel
+
+extension LightdInfo: LightWalletdInfo {}
+extension SendResponse: LightWalletServiceResponse {}
+
+/**
+Swift GRPC implementation of Lightwalletd service
+*/
+enum GRPCResult: Equatable {
+    case success
+    case error(_ error: LightWalletServiceError)
+}
+
+protocol CancellableCall {
+    func cancel()
+}
+
+extension ServerStreamingCall: CancellableCall {
+    func cancel() {
+        self.cancel(promise: self.eventLoop.makePromise(of: Void.self))
+    }
+}
+
+protocol LatestBlockHeightProvider {
+    func latestBlockHeight(streamer: CompactTxStreamerAsyncClient) async throws -> BlockHeight
+}
+
+class LiveLatestBlockHeightProvider: LatestBlockHeightProvider {
+    func latestBlockHeight(streamer: CompactTxStreamerAsyncClient) async throws -> BlockHeight {
+        do {
+            let blockID = try await streamer.getLatestBlock(ChainSpec())
+            guard let blockHeight = Int(exactly: blockID.height) else {
+                throw LightWalletServiceError.generalError(message: "error creating blockheight from BlockID \(blockID)")
+            }
+            return blockHeight
+        } catch {
+            let serviceError = error.mapToServiceError()
+            throw ZcashError.serviceLatestBlockHeightFailed(serviceError)
+        }
+    }
+}
+
+class LightWalletGRPCService {
+    let channel: Channel
+    let connectionManager: ConnectionStatusManager
+    let compactTxStreamer: CompactTxStreamerAsyncClient
+    let singleCallTimeout: TimeLimit
+    let streamingCallTimeout: TimeLimit
+    var latestBlockHeightProvider: LatestBlockHeightProvider = LiveLatestBlockHeightProvider()
+
+    var connectionStateChange: ((_ from: ConnectionState, _ to: ConnectionState) -> Void)? {
+        get { connectionManager.connectionStateChange }
+        set { connectionManager.connectionStateChange = newValue }
+    }
+
+    let queue: DispatchQueue
+    
+    convenience init(endpoint: LightWalletEndpoint) {
+        self.init(
+            host: endpoint.host,
+            port: endpoint.port,
+            secure: endpoint.secure,
+            singleCallTimeout: endpoint.singleCallTimeoutInMillis,
+            streamingCallTimeout: endpoint.streamingCallTimeoutInMillis
+        )
+    }
+
+    /// Inits a connection to a Lightwalletd service to the given
+    /// - Parameters:
+    ///  - host: the hostname of the lightwalletd server
+    ///  - port: port of the server. Default is 9067
+    ///  - secure: whether this server is TLS or plaintext. default True (TLS)
+    ///  - singleCallTimeout: Timeout for unary calls in milliseconds.
+    ///  - streamingCallTimeout: Timeout for streaming calls in milliseconds.
+    init(
+        host: String,
+        port: Int = 9067,
+        secure: Bool = true,
+        singleCallTimeout: Int64,
+        streamingCallTimeout: Int64
+    ) {
+        self.connectionManager = ConnectionStatusManager()
+        self.queue = DispatchQueue.init(label: "LightWalletGRPCService")
+        self.streamingCallTimeout = TimeLimit.timeout(.milliseconds(streamingCallTimeout))
+        self.singleCallTimeout = TimeLimit.timeout(.milliseconds(singleCallTimeout))
+
+        let connectionBuilder = secure ?
+        ClientConnection.usingPlatformAppropriateTLS(for: NIOTSEventLoopGroup(loopCount: 1, defaultQoS: .default)) :
+        ClientConnection.insecure(group: NIOTSEventLoopGroup(loopCount: 1, defaultQoS: .default))
+
+        let channel = connectionBuilder
+            .withConnectivityStateDelegate(connectionManager, executingOn: queue)
+            .connect(host: host, port: port)
+
+        self.channel = channel
+        
+        compactTxStreamer = CompactTxStreamerAsyncClient(
+            channel: self.channel,
+            defaultCallOptions: Self.callOptions(
+                timeLimit: self.singleCallTimeout
+            )
+        )
+    }
+
+    deinit {
+        _ = channel.close()
+        _ = compactTxStreamer.channel.close()
+    }
+
+    func stop() {
+        _ = channel.close()
+    }
+
+    func latestBlock() async throws -> BlockID {
+        do {
+            return try await compactTxStreamer.getLatestBlock(ChainSpec())
+        } catch {
+            let serviceError = error.mapToServiceError()
+            throw ZcashError.serviceLatestBlockFailed(serviceError)
+        }
+    }
+
+    static func callOptions(timeLimit: TimeLimit) -> CallOptions {
+        CallOptions(
+            customMetadata: HPACKHeaders(),
+            timeLimit: timeLimit,
+            messageEncoding: .disabled,
+            requestIDProvider: .autogenerated,
+            requestIDHeader: nil,
+            cacheable: false
+        )
+    }
+}
+
+// MARK: - LightWalletService
+
+extension LightWalletGRPCService: LightWalletService {
+    func getInfo() async throws -> LightWalletdInfo {
+        do {
+            return try await compactTxStreamer.getLightdInfo(Empty())
+        } catch {
+            let serviceError = error.mapToServiceError()
+            throw ZcashError.serviceGetInfoFailed(serviceError)
+        }
+    }
+    
+    func latestBlockHeight() async throws -> BlockHeight {
+        try await latestBlockHeightProvider.latestBlockHeight(streamer: compactTxStreamer)
+    }
+    
+    func blockRange(_ range: CompactBlockRange) -> AsyncThrowingStream<ZcashCompactBlock, Error> {
+        let stream = compactTxStreamer.getBlockRange(range.blockRange())
+        var iterator = stream.makeAsyncIterator()
+        
+        return AsyncThrowingStream() {
+            do {
+                guard let block = try await iterator.next() else { return nil }
+                return ZcashCompactBlock(compactBlock: block)
+            } catch {
+                let serviceError = error.mapToServiceError()
+                throw ZcashError.serviceBlockRangeFailed(serviceError)
+            }
+        }
+    }
+    
+    func submit(spendTransaction: Data) async throws -> LightWalletServiceResponse {
+        do {
+            let transaction = RawTransaction.with { $0.data = spendTransaction }
+            return try await compactTxStreamer.sendTransaction(transaction)
+        } catch {
+            let serviceError = error.mapToServiceError()
+            throw ZcashError.serviceSubmitFailed(serviceError)
+        }
+    }
+    
+    func fetchTransaction(txId: Data) async throws -> ZcashTransaction.Fetched {
+        var txFilter = TxFilter()
+        txFilter.hash = txId
+        
+        do {
+            let rawTx = try await compactTxStreamer.getTransaction(txFilter)
+            return ZcashTransaction.Fetched(rawID: txId, minedHeight: BlockHeight(rawTx.height), raw: rawTx.data)
+        } catch {
+            let serviceError = error.mapToServiceError()
+            throw ZcashError.serviceFetchTransactionFailed(serviceError)
+        }
+    }
+
+    func fetchUTXOs(for tAddress: String, height: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
+        return fetchUTXOs(for: [tAddress], height: height)
+    }
+
+    func fetchUTXOs(
+        for tAddresses: [String],
+        height: BlockHeight
+    ) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
+        guard !tAddresses.isEmpty else {
+            return AsyncThrowingStream { continuation in continuation.finish() }
+        }
+        
+        let args = GetAddressUtxosArg.with { utxoArgs in
+            utxoArgs.addresses = tAddresses
+            utxoArgs.startHeight = UInt64(height)
+        }
+        let stream = compactTxStreamer.getAddressUtxosStream(args)
+        var iterator = stream.makeAsyncIterator()
+
+        return AsyncThrowingStream() {
+            do {
+                guard let reply = try await iterator.next() else { return nil }
+                return 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
+                )
+            } catch {
+                let serviceError = error.mapToServiceError()
+                throw ZcashError.serviceFetchUTXOsFailed(serviceError)
+            }
+        }
+    }
+    
+    func blockStream(
+        startHeight: BlockHeight,
+        endHeight: BlockHeight
+    ) -> AsyncThrowingStream<ZcashCompactBlock, Error> {
+        let stream = compactTxStreamer.getBlockRange(
+            BlockRange(
+                startHeight: startHeight,
+                endHeight: endHeight
+            ),
+            callOptions: Self.callOptions(timeLimit: self.streamingCallTimeout)
+        )
+        var iterator = stream.makeAsyncIterator()
+
+        return AsyncThrowingStream() {
+            do {
+                guard let compactBlock = try await iterator.next() else { return nil }
+                return ZcashCompactBlock(compactBlock: compactBlock)
+            } catch {
+                let serviceError = error.mapToServiceError()
+                throw ZcashError.serviceBlockStreamFailed(serviceError)
+            }
+        }
+    }
+
+    func closeConnection() {
+        _ = channel.close()
+    }
+}
+
+// MARK: - Extensions
+
+extension ConnectivityState {
+    func toConnectionState() -> ConnectionState {
+        switch self {
+        case .connecting:
+            return .connecting
+        case .idle:
+            return .idle
+        case .ready:
+            return .online
+        case .shutdown:
+            return .shutdown
+        case .transientFailure:
+            return .reconnecting
+        }
+    }
+}
+
+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 {
+    var connectionStateChange: ((_ from: ConnectionState, _ to: ConnectionState) -> Void)?
+    init() { }
+
+    func connectivityStateDidChange(from oldState: ConnectivityState, to newState: ConnectivityState) {
+        connectionStateChange?(oldState.toConnectionState(), newState.toConnectionState())
+    }
+}

package/ios/ZCashLightClientKit/Modules/Service/GRPC/ProtoBuf/Extensions/Protocolbuffer+Extensions.swift

@@ -0,0 +1,50 @@
+//
+//  Protocolbuffer+Extensions.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 12/09/2019.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+extension CompactBlockRange {
+    func blockRange() -> BlockRange {
+        BlockRange(startHeight: lowerBound, endHeight: upperBound)
+    }
+}
+
+extension BlockID {
+    init(height: UInt64) {
+        self = BlockID()
+        self.height = height
+    }
+    
+    init(height: BlockHeight) {
+        self.init(height: UInt64(height))
+    }
+    
+    func compactBlockHeight() -> BlockHeight? {
+        BlockHeight(exactly: self.height)
+    }
+}
+
+extension BlockRange {
+    init(startHeight: Int, endHeight: Int? = nil) {
+        self = BlockRange()
+        self.start = BlockID(height: UInt64(startHeight))
+        if let endHeight {
+            self.end = BlockID(height: UInt64(endHeight))
+        }
+    }
+    
+    var compactBlockRange: CompactBlockRange {
+        return Int(self.start.height) ... Int(self.end.height)
+    }
+}
+
+extension Array where Element == CompactBlock {
+    func asZcashCompactBlocks() -> [ZcashCompactBlock] {
+        self.map { ZcashCompactBlock(compactBlock: $0) }
+    }
+}