react-native-zcash 0.9.12 → 0.10.0

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

@@ -54,21 +54,29 @@ class LiveLatestBlockHeightProvider: LatestBlockHeightProvider {
     }
 }
 
-class LightWalletGRPCService {
-    let channel: Channel
-    let connectionManager: ConnectionStatusManager
-    let compactTxStreamer: CompactTxStreamerAsyncClient
+// swiftlint:disable:next type_body_length
+class LightWalletGRPCService: LightWalletService {
+    var channel: Channel?
+    var connectionManager: ConnectionStatusManager?
+    var compactTxStreamerInternal: CompactTxStreamerAsyncClient?
+    var compactTxStreamer: CompactTxStreamerAsyncClient {
+        resolveLazyConnect()
+    }
     let singleCallTimeout: TimeLimit
     let streamingCallTimeout: TimeLimit
     var latestBlockHeightProvider: LatestBlockHeightProvider = LiveLatestBlockHeightProvider()
 
+    let host: String
+    let port: Int
+    let secure: Bool
+
     var connectionStateChange: ((_ from: ConnectionState, _ to: ConnectionState) -> Void)? {
-        get { connectionManager.connectionStateChange }
-        set { connectionManager.connectionStateChange = newValue }
+        get { connectionManager?.connectionStateChange }
+        set { connectionManager?.connectionStateChange = newValue }
     }
 
     let queue: DispatchQueue
-    
+
     convenience init(endpoint: LightWalletEndpoint) {
         self.init(
             host: endpoint.host,
@@ -79,6 +87,16 @@ class LightWalletGRPCService {
         )
     }
 
+    convenience init(endpoint: LightWalletEndpoint, torURL: URL) {
+        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
@@ -98,34 +116,56 @@ class LightWalletGRPCService {
         self.streamingCallTimeout = TimeLimit.timeout(.milliseconds(streamingCallTimeout))
         self.singleCallTimeout = TimeLimit.timeout(.milliseconds(singleCallTimeout))
 
+        self.host = host
+        self.port = port
+        self.secure = secure
+    }
+
+    deinit {
+        _ = channel?.close()
+        _ = compactTxStreamer.channel.close()
+    }
+
+    func resolveLazyConnect() -> CompactTxStreamerAsyncClient {
+        guard self.channel == nil else {
+            if let compactTxStreamerInternal {
+                return compactTxStreamerInternal
+            } else {
+                fatalError("Initialization of CompactTxStreamerAsyncClient failed")
+            }
+        }
+
         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,
+
+        let compactTxStreamerInstance = CompactTxStreamerAsyncClient(
+            channel: channel,
             defaultCallOptions: Self.callOptions(
                 timeLimit: self.singleCallTimeout
             )
         )
-    }
-
-    deinit {
-        _ = channel.close()
-        _ = compactTxStreamer.channel.close()
+        
+        self.compactTxStreamerInternal = compactTxStreamerInstance
+        
+        return compactTxStreamerInstance
     }
 
     func stop() {
-        _ = channel.close()
+        _ = channel?.close()
     }
 
-    func latestBlock() async throws -> BlockID {
+    func latestBlock(mode: ServiceMode) async throws -> BlockID {
+        guard mode == .direct else {
+            throw ZcashError.grpcServiceCalledWithTorMode
+        }
+
         do {
             return try await compactTxStreamer.getLatestBlock(ChainSpec())
         } catch {
@@ -144,12 +184,12 @@ class LightWalletGRPCService {
             cacheable: false
         )
     }
-}
 
-// MARK: - LightWalletService
-
-extension LightWalletGRPCService: LightWalletService {
-    func getInfo() async throws -> LightWalletdInfo {
+    func getInfo(mode: ServiceMode) async throws -> LightWalletdInfo {
+        guard mode == .direct else {
+            throw ZcashError.grpcServiceCalledWithTorMode
+        }
+        
         do {
             return try await compactTxStreamer.getLightdInfo(Empty())
         } catch {
@@ -157,12 +197,20 @@ extension LightWalletGRPCService: LightWalletService {
             throw ZcashError.serviceGetInfoFailed(serviceError)
         }
     }
-    
-    func latestBlockHeight() async throws -> BlockHeight {
-        try await latestBlockHeightProvider.latestBlockHeight(streamer: compactTxStreamer)
+
+    func latestBlockHeight(mode: ServiceMode) async throws -> BlockHeight {
+        guard mode == .direct else {
+            throw ZcashError.grpcServiceCalledWithTorMode
+        }
+
+        return try await latestBlockHeightProvider.latestBlockHeight(streamer: compactTxStreamer)
     }
-    
-    func blockRange(_ range: CompactBlockRange) -> AsyncThrowingStream<ZcashCompactBlock, Error> {
+
+    func blockRange(_ range: CompactBlockRange, mode: ServiceMode) throws -> AsyncThrowingStream<ZcashCompactBlock, Error> {
+        guard mode == .direct else {
+            throw ZcashError.grpcServiceCalledWithTorMode
+        }
+
         let stream = compactTxStreamer.getBlockRange(range.blockRange())
         var iterator = stream.makeAsyncIterator()
         
@@ -176,8 +224,12 @@ extension LightWalletGRPCService: LightWalletService {
             }
         }
     }
-    
-    func submit(spendTransaction: Data) async throws -> LightWalletServiceResponse {
+
+    func submit(spendTransaction: Data, mode: ServiceMode) async throws -> LightWalletServiceResponse {
+        guard mode == .direct else {
+            throw ZcashError.grpcServiceCalledWithTorMode
+        }
+
         do {
             let transaction = RawTransaction.with { $0.data = spendTransaction }
             return try await compactTxStreamer.sendTransaction(transaction)
@@ -186,8 +238,12 @@ extension LightWalletGRPCService: LightWalletService {
             throw ZcashError.serviceSubmitFailed(serviceError)
         }
     }
-    
-    func fetchTransaction(txId: Data) async throws -> (tx: ZcashTransaction.Fetched?, status: TransactionStatus) {
+
+    func fetchTransaction(txId: Data, mode: ServiceMode) async throws -> (tx: ZcashTransaction.Fetched?, status: TransactionStatus) {
+        guard mode == .direct else {
+            throw ZcashError.grpcServiceCalledWithTorMode
+        }
+
         var txFilter = TxFilter()
         txFilter.hash = txId
         
@@ -206,11 +262,15 @@ extension LightWalletGRPCService: LightWalletService {
                 status: isNotMined ? .notInMainChain : .mined(Int(rawTx.height))
             )
         } catch let error as GRPCStatus {
+            let noMempoolMsg = "No such mempool or blockchain transaction. Use gettransaction for wallet transactions."
+
             if error.makeGRPCStatus().code == .notFound {
                 return (tx: nil, .txidNotRecognized)
             } else if let notFound = error.message?.contains("Transaction not found"), notFound {
                 return (tx: nil, .txidNotRecognized)
-            } else if let notFound = error.message?.contains("No such mempool or blockchain transaction. Use gettransaction for wallet transactions."), notFound {
+            } else if let notFound = error.message?.contains("No such mempool or main chain transaction"), notFound {
+                return (tx: nil, .txidNotRecognized)
+            } else if let notFound = error.message?.contains(noMempoolMsg), notFound {
                 return (tx: nil, .txidNotRecognized)
             } else {
                 let serviceError = error.mapToServiceError()
@@ -222,14 +282,23 @@ extension LightWalletGRPCService: LightWalletService {
         }
     }
 
-    func fetchUTXOs(for tAddress: String, height: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
-        return fetchUTXOs(for: [tAddress], height: height)
+    func fetchUTXOs(for tAddress: String, height: BlockHeight, mode: ServiceMode) throws -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
+        guard mode == .direct else {
+            throw ZcashError.grpcServiceCalledWithTorMode
+        }
+
+        return try fetchUTXOs(for: [tAddress], height: height, mode: mode)
     }
 
     func fetchUTXOs(
         for tAddresses: [String],
-        height: BlockHeight
-    ) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
+        height: BlockHeight,
+        mode: ServiceMode
+    ) throws -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
+        guard mode == .direct else {
+            throw ZcashError.grpcServiceCalledWithTorMode
+        }
+
         guard !tAddresses.isEmpty else {
             return AsyncThrowingStream { continuation in continuation.finish() }
         }
@@ -261,8 +330,13 @@ extension LightWalletGRPCService: LightWalletService {
     
     func blockStream(
         startHeight: BlockHeight,
-        endHeight: BlockHeight
-    ) -> AsyncThrowingStream<ZcashCompactBlock, Error> {
+        endHeight: BlockHeight,
+        mode: ServiceMode
+    ) throws -> AsyncThrowingStream<ZcashCompactBlock, Error> {
+        guard mode == .direct else {
+            throw ZcashError.grpcServiceCalledWithTorMode
+        }
+
         let stream = compactTxStreamer.getBlockRange(
             BlockRange(
                 startHeight: startHeight,
@@ -283,7 +357,26 @@ extension LightWalletGRPCService: LightWalletService {
         }
     }
     
-    func getSubtreeRoots(_ request: GetSubtreeRootsArg) -> AsyncThrowingStream<SubtreeRoot, Error> {
+    func getMempoolStream() throws -> AsyncThrowingStream<RawTransaction, Error> {
+        let stream = compactTxStreamer.getMempoolStream(Empty())
+        var iterator = stream.makeAsyncIterator()
+        
+        return AsyncThrowingStream() {
+            do {
+                guard let rawTransaction = try await iterator.next() else { return nil }
+                return rawTransaction
+            } catch {
+                let serviceError = error.mapToServiceError()
+                throw ZcashError.serviceGetMempoolStreamFailed(serviceError)
+            }
+        }
+    }
+    
+    func getSubtreeRoots(_ request: GetSubtreeRootsArg, mode: ServiceMode) throws -> AsyncThrowingStream<SubtreeRoot, Error> {
+        guard mode == .direct else {
+            throw ZcashError.grpcServiceCalledWithTorMode
+        }
+
         let stream = compactTxStreamer.getSubtreeRoots(request)
         var iterator = stream.makeAsyncIterator()
         
@@ -298,11 +391,19 @@ extension LightWalletGRPCService: LightWalletService {
         }
     }
 
-    func getTreeState(_ id: BlockID) async throws -> TreeState {
-        try await compactTxStreamer.getTreeState(id)
+    func getTreeState(_ id: BlockID, mode: ServiceMode) async throws -> TreeState {
+        guard mode == .direct else {
+            throw ZcashError.grpcServiceCalledWithTorMode
+        }
+
+        return try await compactTxStreamer.getTreeState(id)
     }
 
-    func getTaddressTxids(_ request: TransparentAddressBlockFilter) -> AsyncThrowingStream<RawTransaction, Error> {
+    func getTaddressTxids(_ request: TransparentAddressBlockFilter, mode: ServiceMode) throws -> AsyncThrowingStream<RawTransaction, Error> {
+        guard mode == .direct else {
+            throw ZcashError.grpcServiceCalledWithTorMode
+        }
+
         let stream = compactTxStreamer.getTaddressTxids(request)
         var iterator = stream.makeAsyncIterator()
         
@@ -317,8 +418,39 @@ extension LightWalletGRPCService: LightWalletService {
         }
     }
     
-    func closeConnection() {
-        _ = channel.close()
+    func checkSingleUseTransparentAddresses(
+        dbData: (String, UInt),
+        networkType: NetworkType,
+        accountUUID: AccountUUID,
+        mode: ServiceMode
+    ) async throws -> TransparentAddressCheckResult {
+        .torRequired
+    }
+    
+    // swiftlint:disable:next function_parameter_count
+    func updateTransparentAddressTransactions(
+        address: String,
+        start: BlockHeight,
+        end: BlockHeight,
+        dbData: (String, UInt),
+        networkType: NetworkType,
+        mode: ServiceMode
+    ) async throws -> TransparentAddressCheckResult {
+        .torRequired
+    }
+    
+    func fetchUTXOsByAddress(
+        address: String,
+        dbData: (String, UInt),
+        networkType: NetworkType,
+        accountUUID: AccountUUID,
+        mode: ServiceMode
+    ) async throws -> TransparentAddressCheckResult {
+        .torRequired
+    }
+    
+    func closeConnections() async {
+        _ = channel?.close()
     }
 }
 

package/ios/ZCashLightClientKit/Modules/Service/LightWalletService.swift

@@ -24,7 +24,7 @@ public enum LightWalletServiceError: Error {
 }
 
 extension LightWalletServiceError: Equatable {
-    // swiftlint:disable cyclomatic_complexity
+    // swiftlint:disable:next cyclomatic_complexity
     public static func == (lhs: Self, rhs: Self) -> Bool {
         switch lhs {
         case .generalError(let message):
@@ -142,62 +142,109 @@ struct LightWalletServiceFactory {
     }
 }
 
+/// Mode that determines which connection is used for the lightwalletd networking calls.
+enum ServiceMode: Equatable {
+    /// Default Tor connection is used, lives for the lifetime of the Synchronizer.
+    case defaultTor
+    /// GRPC connection is used, no Tor involved.
+    case direct
+    /// Tor connection is used tagged by a given group name (String). Tags are held in memory for the lifetime of the Synchronizer.
+    case torInGroup(String)
+    /// Tor connection is used, each time a new one, not held in memory, used only once.
+    case uniqueTor
+
+    /// Helper method that generates a tagged group for a given transaction ID with a prefix. 
+    static func txIdGroup(prefix: String, txId: Data) -> ServiceMode {
+        torInGroup("\(prefix)-\(txId.hexEncodedString())")
+    }
+}
+
 protocol LightWalletService: AnyObject {
     /// Closure which is called when connection state changes.
     var connectionStateChange: ((_ from: ConnectionState, _ to: ConnectionState) -> Void)? { get set }
 
     /// Returns the info for this lightwalletd server
     /// - Throws: `serviceGetInfoFailed` when GRPC call fails.
-    func getInfo() async throws -> LightWalletdInfo
+    func getInfo(mode: ServiceMode) async throws -> LightWalletdInfo
 
     /// - Throws: `serviceLatestBlockHeightFailed` when GRPC call fails.
-    func latestBlock() async throws -> BlockID
+    func latestBlock(mode: ServiceMode) async throws -> BlockID
 
     /// Return the latest block height known to the service.
     /// - Throws: `serviceLatestBlockFailed` when GRPC call fails.
-    func latestBlockHeight() async throws -> BlockHeight
+    func latestBlockHeight(mode: ServiceMode) async throws -> BlockHeight
 
     /// Return the given range of blocks.
     /// - Parameter range: the inclusive range to fetch.
     ///     For instance if 1..5 is given, then every block in that will be fetched, including 1 and 5.
     /// - Throws: `serviceBlockRangeFailed` when GRPC call fails.
-    func blockRange(_ range: CompactBlockRange) -> AsyncThrowingStream<ZcashCompactBlock, Error>
+    func blockRange(_ range: CompactBlockRange, mode: ServiceMode) throws -> AsyncThrowingStream<ZcashCompactBlock, Error>
     
     /// Submits a raw transaction over lightwalletd.
     /// - Parameter spendTransaction: data representing the transaction to be sent
     /// - Throws: `serviceSubmitFailed` when GRPC call fails.
-    func submit(spendTransaction: Data) async throws -> LightWalletServiceResponse
-    
+    func submit(spendTransaction: Data, mode: ServiceMode) async throws -> LightWalletServiceResponse
+
     /// Gets a transaction by id
     /// - Parameter txId: data representing the transaction ID
     /// - Throws: LightWalletServiceError
     /// - Returns: LightWalletServiceResponse
     /// - Throws: `serviceFetchTransactionFailed` when GRPC call fails.
-    func fetchTransaction(txId: Data) async throws -> (tx: ZcashTransaction.Fetched?, status: TransactionStatus)
+    func fetchTransaction(txId: Data, mode: ServiceMode) async throws -> (tx: ZcashTransaction.Fetched?, status: TransactionStatus)
 
     /// - Throws: `serviceFetchUTXOsFailed` when GRPC call fails.
     // sourcery: mockedName="fetchUTXOsSingle"
-    func fetchUTXOs(for tAddress: String, height: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>
+    func fetchUTXOs(for tAddress: String, height: BlockHeight, mode: ServiceMode) throws -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>
 
     /// - Throws: `serviceFetchUTXOsFailed` when GRPC call fails.
-    func fetchUTXOs(for tAddresses: [String], height: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>
+    func fetchUTXOs(for tAddresses: [String], height: BlockHeight, mode: ServiceMode) throws -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>
 
     /// - Throws: `serviceBlockStreamFailed` when GRPC call fails.
     func blockStream(
         startHeight: BlockHeight,
-        endHeight: BlockHeight
-    ) -> AsyncThrowingStream<ZcashCompactBlock, Error>
+        endHeight: BlockHeight,
+        mode: ServiceMode
+    ) throws -> AsyncThrowingStream<ZcashCompactBlock, Error>
 
-    func closeConnection()
+    /// Used for potential closure of channels or connections.
+    /// Example:` LightWalletGRPCServiceOverTor` inherits `LightWalletService` and closes Tor connections.
+    func closeConnections() async
     
     /// Returns a stream of information about roots of subtrees of the Sapling and Orchard
     /// note commitment trees.
     ///
     /// - Parameters:
     ///   - request: Request to send to GetSubtreeRoots.
-    func getSubtreeRoots(_ request: GetSubtreeRootsArg) -> AsyncThrowingStream<SubtreeRoot, Error>
+    func getSubtreeRoots(_ request: GetSubtreeRootsArg, mode: ServiceMode) throws -> AsyncThrowingStream<SubtreeRoot, Error>
 
-    func getTreeState(_ id: BlockID) async throws -> TreeState
+    func getTreeState(_ id: BlockID, mode: ServiceMode) async throws -> TreeState
+
+    func getTaddressTxids(_ request: TransparentAddressBlockFilter, mode: ServiceMode) throws -> AsyncThrowingStream<RawTransaction, Error>
+    
+    func getMempoolStream() throws -> AsyncThrowingStream<RawTransaction, Error>
+    
+    func checkSingleUseTransparentAddresses(
+        dbData: (String, UInt),
+        networkType: NetworkType,
+        accountUUID: AccountUUID,
+        mode: ServiceMode
+    ) async throws -> TransparentAddressCheckResult
+    
+    // swiftlint:disable:next function_parameter_count
+    func updateTransparentAddressTransactions(
+        address: String,
+        start: BlockHeight,
+        end: BlockHeight,
+        dbData: (String, UInt),
+        networkType: NetworkType,
+        mode: ServiceMode
+    ) async throws -> TransparentAddressCheckResult
     
-    func getTaddressTxids(_ request: TransparentAddressBlockFilter) -> AsyncThrowingStream<RawTransaction, Error>
+    func fetchUTXOsByAddress(
+        address: String,
+        dbData: (String, UInt),
+        networkType: NetworkType,
+        accountUUID: AccountUUID,
+        mode: ServiceMode
+    ) async throws -> TransparentAddressCheckResult
 }