react-native-zcash 0.9.13 → 0.10.1-beta.1

package/ios/ZCashLightClientKit/Synchronizer/SDKSynchronizer.swift

@@ -10,8 +10,12 @@ import Foundation
 import Combine
 
 /// Synchronizer implementation for UIKit and iOS 13+
-// swiftlint:disable type_body_length
+// swiftlint:disable type_body_length file_length
 public class SDKSynchronizer: Synchronizer {
+    private enum Constants {
+        static let fixWitnessesLastVersionCall = "ud_fixWitnessesLastVersionCall"
+    }
+    
     public var alias: ZcashSynchronizerAlias { initializer.alias }
 
     private lazy var streamsUpdateQueue = { DispatchQueue(label: "streamsUpdateQueue_\(initializer.alias.description)") }()
@@ -27,7 +31,9 @@ public class SDKSynchronizer: Synchronizer {
     
     let metrics: SDKMetrics
     public let logger: Logger
-    var tor: TorClient?
+    var exchangeRateTor: TorClient?
+    var httpTor: TorClient?
+    let sdkFlags: SDKFlags
 
     // Don't read this variable directly. Use `status` instead. And don't update this variable directly use `updateStatus()` methods instead.
     private var underlyingStatus: GenericActor<InternalSyncStatus>
@@ -86,6 +92,7 @@ public class SDKSynchronizer: Synchronizer {
         self.syncSession = SyncSession(.nullID)
         self.syncSessionTicker = syncSessionTicker
         self.latestBlocksDataProvider = initializer.container.resolve(LatestBlocksDataProvider.self)
+        self.sdkFlags = initializer.container.resolve(SDKFlags.self)
 
         initializer.lightWalletService.connectionStateChange = { [weak self] oldState, newState in
             self?.connectivityStateChanged(oldState: oldState, newState: newState)
@@ -97,7 +104,6 @@ public class SDKSynchronizer: Synchronizer {
     }
 
     deinit {
-        UsedAliasesChecker.stopUsing(alias: initializer.alias, id: initializer.id)
         Task { [blockProcessor] in
             await blockProcessor.stop()
         }
@@ -120,17 +126,15 @@ public class SDKSynchronizer: Synchronizer {
             return initialisationError
         }
 
-        if !UsedAliasesChecker.tryToUse(alias: initializer.alias, id: initializer.id) {
-            return .initializerAliasAlreadyInUse(initializer.alias)
-        }
-
         return nil
     }
 
     public func prepare(
         with seed: [UInt8]?,
         walletBirthday: BlockHeight,
-        for walletMode: WalletInitMode
+        for walletMode: WalletInitMode,
+        name: String,
+        keySource: String?
     ) async throws -> Initializer.InitializationResult {
         guard await status == .unprepared else { return .success }
 
@@ -138,7 +142,13 @@ public class SDKSynchronizer: Synchronizer {
             throw error
         }
 
-        if case .seedRequired = try await self.initializer.initialize(with: seed, walletBirthday: walletBirthday, for: walletMode) {
+        if case .seedRequired = try await self.initializer.initialize(
+            with: seed,
+            walletBirthday: walletBirthday,
+            for: walletMode,
+            name: name,
+            keySource: keySource
+        ) {
             return .seedRequired
         }
         
@@ -147,6 +157,8 @@ public class SDKSynchronizer: Synchronizer {
         
         await updateStatus(.disconnected, updateExternalStatus: false)
 
+        await resolveWitnessesFix()
+        
         return .success
     }
 
@@ -159,13 +171,42 @@ public class SDKSynchronizer: Synchronizer {
 
         case .syncing:
             logger.warn("warning: Synchronizer started when already running. Next sync process will be started when the current one stops.")
+            await exchangeRateTor?.wake()
+            await httpTor?.wake()
             /// This may look strange but `CompactBlockProcessor` has mechanisms which can handle this situation. So we are fine with calling
             /// it's start here.
             await blockProcessor.start(retry: retry)
 
         case .stopped, .synced, .disconnected, .error:
-            let syncProgress = (try? await initializer.rustBackend.getWalletSummary()?.scanProgress?.progress()) ?? 0
-            await updateStatus(.syncing(syncProgress))
+            let walletSummary = try? await initializer.rustBackend.getWalletSummary()
+            let recoveryProgress = walletSummary?.recoveryProgress
+            
+            var syncProgress: Float = 0.0
+            var areFundsSpendable = false
+            
+            if let scanProgress = walletSummary?.scanProgress {
+                let composedNumerator = Float(scanProgress.numerator) + Float(recoveryProgress?.numerator ?? 0)
+                let composedDenominator = Float(scanProgress.denominator) + Float(recoveryProgress?.denominator ?? 0)
+                
+                let progress: Float
+                if composedDenominator == 0 {
+                    progress = 1.0
+                } else {
+                    progress = composedNumerator / composedDenominator
+                }
+                
+                // this shouldn't happen but if it does, we need to get notified by clients and work on a fix
+                if progress > 1.0 {
+                    throw ZcashError.rustScanProgressOutOfRange("\(progress)")
+                }
+
+                areFundsSpendable = scanProgress.isComplete
+
+                syncProgress = progress
+            }
+            await updateStatus(.syncing(syncProgress, areFundsSpendable))
+            await exchangeRateTor?.wake()
+            await httpTor?.wake()
             await blockProcessor.start(retry: retry)
         }
     }
@@ -176,6 +217,8 @@ public class SDKSynchronizer: Synchronizer {
         // downloading is really done. Which could block execution of the code on the client side. So it's better strategy to spin up new task and
         // exit fast on client side.
         Task(priority: .high) {
+            await sdkFlags.sdkStopped()
+            
             let status = await self.status
             guard status != .stopped, status != .disconnected else {
                 logger.info("attempted to stop when status was: \(status)")
@@ -183,7 +226,27 @@ public class SDKSynchronizer: Synchronizer {
             }
 
             await blockProcessor.stop()
+            await exchangeRateTor?.sleep()
+            await httpTor?.sleep()
+        }
+    }
+
+    // MARK: Witnesses Fix
+    
+    private func resolveWitnessesFix() async {
+        let appVersion = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? ""
+        
+        guard let lastVersionCall = UserDefaults.standard.object(forKey: Constants.fixWitnessesLastVersionCall) as? String else {
+            UserDefaults.standard.set(appVersion, forKey: Constants.fixWitnessesLastVersionCall)
+            await initializer.rustBackend.fixWitnesses()
+            return
+        }
+        
+        guard lastVersionCall < appVersion else {
+            return
         }
+
+        await initializer.rustBackend.fixWitnesses()
     }
 
     // MARK: Connectivity State
@@ -213,8 +276,8 @@ public class SDKSynchronizer: Synchronizer {
                 // log reorg information
                 self?.logger.info("handling reorg at: \(reorgHeight) with rewind height: \(rewindHeight)")
 
-            case let .progressUpdated(progress):
-                await self?.progressUpdated(progress: progress)
+            case let .progressUpdated(syncProgress, areFundsSpendable):
+                await self?.progressUpdated(syncProgress, areFundsSpendable)
 
             case .syncProgress:
                 break
@@ -247,13 +310,15 @@ public class SDKSynchronizer: Synchronizer {
     }
 
     private func foundTransactions(transactions: [ZcashTransaction.Overview], in range: CompactBlockRange) {
+        guard !transactions.isEmpty else { return }
+        
         streamsUpdateQueue.async { [weak self] in
             self?.eventSubject.send(.foundTransactions(transactions, range))
         }
     }
 
-    private func progressUpdated(progress: Float) async {
-        let newStatus = InternalSyncStatus(progress)
+    private func progressUpdated(_ syncProgress: Float, _ areFundsSpendable: Bool) async {
+        let newStatus = InternalSyncStatus(syncProgress, areFundsSpendable)
         await updateStatus(newStatus)
     }
 
@@ -265,7 +330,47 @@ public class SDKSynchronizer: Synchronizer {
 
     // MARK: Synchronizer methods
 
-    public func proposeTransfer(accountIndex: Int, recipient: Recipient, amount: Zatoshi, memo: Memo?) async throws -> Proposal {
+    public func listAccounts() async throws -> [Account] {
+        try await initializer.rustBackend.listAccounts()
+    }
+    
+    // swiftlint:disable:next function_parameter_count
+    public func importAccount(
+        ufvk: String,
+        seedFingerprint: [UInt8]?,
+        zip32AccountIndex: Zip32AccountIndex?,
+        purpose: AccountPurpose,
+        name: String,
+        keySource: String?
+    ) async throws -> AccountUUID {
+        // called when a new account is imported
+        let chainTip = try? await UInt32(
+            initializer.lightWalletService.latestBlockHeight(
+                mode: await sdkFlags.ifTor(.uniqueTor)
+            )
+        )
+
+        let checkpointSource = initializer.container.resolve(CheckpointSource.self)
+
+        guard let chainTip else {
+            throw ZcashError.synchronizerNotPrepared
+        }
+        
+        let checkpoint = checkpointSource.birthday(for: BlockHeight(chainTip))
+            
+        return try await initializer.rustBackend.importAccount(
+            ufvk: ufvk,
+            seedFingerprint: seedFingerprint,
+            zip32AccountIndex: zip32AccountIndex,
+            treeState: checkpoint.treeState(),
+            recoverUntil: chainTip,
+            purpose: purpose,
+            name: name,
+            keySource: keySource
+        )
+    }
+
+    public func proposeTransfer(accountUUID: AccountUUID, recipient: Recipient, amount: Zatoshi, memo: Memo?) async throws -> Proposal {
         try throwIfUnprepared()
 
         if case Recipient.transparent = recipient, memo != nil {
@@ -273,7 +378,7 @@ public class SDKSynchronizer: Synchronizer {
         }
 
         let proposal = try await transactionEncoder.proposeTransfer(
-            accountIndex: accountIndex,
+            accountUUID: accountUUID,
             recipient: recipient.stringEncoded,
             amount: amount,
             memoBytes: memo?.asMemoBytes()
@@ -283,7 +388,7 @@ public class SDKSynchronizer: Synchronizer {
     }
 
     public func proposeShielding(
-        accountIndex: Int,
+        accountUUID: AccountUUID,
         shieldingThreshold: Zatoshi,
         memo: Memo,
         transparentReceiver: TransparentAddress? = nil
@@ -291,7 +396,7 @@ public class SDKSynchronizer: Synchronizer {
         try throwIfUnprepared()
 
         return try await transactionEncoder.proposeShielding(
-            accountIndex: accountIndex,
+            accountUUID: accountUUID,
             shieldingThreshold: shieldingThreshold,
             memoBytes: memo.asMemoBytes(),
             transparentReceiver: transparentReceiver?.stringEncoded
@@ -300,13 +405,13 @@ public class SDKSynchronizer: Synchronizer {
 
     public func proposefulfillingPaymentURI(
         _ uri: String,
-        accountIndex: Int
+        accountUUID: AccountUUID
     ) async throws -> Proposal {
         do {
             try throwIfUnprepared()
             return try await transactionEncoder.proposeFulfillingPaymentFromURI(
                 uri,
-                accountIndex: accountIndex
+                accountUUID: accountUUID
             )
         } catch ZcashError.rustCreateToAddress(let error) {
             throw ZcashError.rustProposeTransferFromURI(error)
@@ -333,9 +438,19 @@ public class SDKSynchronizer: Synchronizer {
             proposal: proposal,
             spendingKey: spendingKey
         )
+        
+        return submitTransactions(transactions)
+    }
+    
+    func submitTransactions(_ transactions: [ZcashTransaction.Overview]) -> AsyncThrowingStream<TransactionSubmitResult, Error> {
         var iterator = transactions.makeIterator()
         var submitFailed = false
 
+        // let clients know the transaction repository changed
+        if !transactions.isEmpty {
+            eventSubject.send(.foundTransactions(transactions, nil))
+        }
+        
         return AsyncThrowingStream() {
             guard let transaction = iterator.next() else { return nil }
 
@@ -357,19 +472,30 @@ public class SDKSynchronizer: Synchronizer {
             }
         }
     }
+    
+    public func createPCZTFromProposal(accountUUID: AccountUUID, proposal: Proposal) async throws -> Pczt {
+        try await initializer.rustBackend.createPCZTFromProposal(
+            accountUUID: accountUUID,
+            proposal: proposal.inner
+        )
+    }
 
-    public func sendToAddress(
-        spendingKey: UnifiedSpendingKey,
-        zatoshi: Zatoshi,
-        toAddress: Recipient,
-        memo: Memo?
-    ) async throws -> ZcashTransaction.Overview {
-        try throwIfUnprepared()
+    public func redactPCZTForSigner(pczt: Pczt) async throws -> Pczt {
+        try await initializer.rustBackend.redactPCZTForSigner(
+            pczt: pczt
+        )
+    }
 
-        if case Recipient.transparent = toAddress, memo != nil {
-            throw ZcashError.synchronizerSendMemoToTransparentAddress
-        }
+    public func PCZTRequiresSaplingProofs(pczt: Pczt) async -> Bool {
+        await initializer.rustBackend.PCZTRequiresSaplingProofs(
+            pczt: pczt
+        )
+    }
 
+    public func addProofsToPCZT(pczt: Pczt) async throws -> Pczt {
+        // TODO [#1724]: zcash_client_backend: Make Sapling parameters optional for extract_and_store_transaction
+        // TODO [#1724]: https://github.com/zcash/librustzcash/issues/1724
+//        if await initializer.rustBackend.PCZTRequiresSaplingProofs(pczt: pczt) {
         try await SaplingParameterDownloader.downloadParamsIfnotPresent(
             spendURL: initializer.spendParamsURL,
             spendSourceURL: initializer.saplingParamsSourceURL.spendParamFileURL,
@@ -377,108 +503,75 @@ public class SDKSynchronizer: Synchronizer {
             outputSourceURL: initializer.saplingParamsSourceURL.outputParamFileURL,
             logger: logger
         )
+//        }
 
-        return try await createToAddress(
-            spendingKey: spendingKey,
-            zatoshi: zatoshi,
-            recipient: toAddress,
-            memo: memo
+        return try await initializer.rustBackend.addProofsToPCZT(
+            pczt: pczt
         )
     }
-
-    public func shieldFunds(
-        spendingKey: UnifiedSpendingKey,
-        memo: Memo,
-        shieldingThreshold: Zatoshi
-    ) async throws -> ZcashTransaction.Overview {
+    
+    public func createTransactionFromPCZT(pcztWithProofs: Pczt, pcztWithSigs: Pczt) async throws -> AsyncThrowingStream<TransactionSubmitResult, Error> {
         try throwIfUnprepared()
 
-        // let's see if there are funds to shield
-        let accountIndex = Int(spendingKey.account)
-
-        guard let tBalance = try await self.getAccountBalance(accountIndex: accountIndex)?.unshielded else {
-            throw ZcashError.synchronizerSpendingKeyDoesNotBelongToTheWallet
-        }
-
-        // Verify that at least there are funds for the fee. Ideally this logic will be improved by the shielding wallet.
-        guard tBalance >= self.network.constants.defaultFee() else {
-            throw ZcashError.synchronizerShieldFundsInsuficientTransparentFunds
-        }
-
-        guard let proposal = try await transactionEncoder.proposeShielding(
-            accountIndex: Int(spendingKey.account),
-            shieldingThreshold: shieldingThreshold,
-            memoBytes: memo.asMemoBytes(),
-            transparentReceiver: nil
-        ) else { throw ZcashError.synchronizerShieldFundsInsuficientTransparentFunds }
-
-        let transactions = try await transactionEncoder.createProposedTransactions(
-            proposal: proposal,
-            spendingKey: spendingKey
+        try await SaplingParameterDownloader.downloadParamsIfnotPresent(
+            spendURL: initializer.spendParamsURL,
+            spendSourceURL: initializer.saplingParamsSourceURL.spendParamFileURL,
+            outputURL: initializer.outputParamsURL,
+            outputSourceURL: initializer.saplingParamsSourceURL.outputParamFileURL,
+            logger: logger
         )
 
-        assert(transactions.count == 1, "Rust backend doesn't produce multiple transactions yet")
-        let transaction = transactions[0]
-
-        let encodedTx = try transaction.encodedTransaction()
-
-        try await transactionEncoder.submit(transaction: encodedTx)
+        let txId = try await initializer.rustBackend.extractAndStoreTxFromPCZT(
+            pcztWithProofs: pcztWithProofs,
+            pcztWithSigs: pcztWithSigs
+        )
 
-        return transaction
+        let transactions = try await transactionEncoder.fetchTransactionsForTxIds([txId])
+        
+        return submitTransactions(transactions)
     }
 
-    func createToAddress(
-        spendingKey: UnifiedSpendingKey,
-        zatoshi: Zatoshi,
-        recipient: Recipient,
-        memo: Memo?
-    ) async throws -> ZcashTransaction.Overview {
-        do {
-            if
-                case .transparent = recipient,
-                memo != nil {
-                throw ZcashError.synchronizerSendMemoToTransparentAddress
-            }
-
-            let proposal = try await transactionEncoder.proposeTransfer(
-                accountIndex: Int(spendingKey.account),
-                recipient: recipient.stringEncoded,
-                amount: zatoshi,
-                memoBytes: memo?.asMemoBytes()
-            )
-
-            let transactions = try await transactionEncoder.createProposedTransactions(
-                proposal: proposal,
-                spendingKey: spendingKey
-            )
-
-            assert(transactions.count == 1, "Rust backend doesn't produce multiple transactions yet")
-            let transaction = transactions[0]
-
-            let encodedTransaction = try transaction.encodedTransaction()
-
-            try await transactionEncoder.submit(transaction: encodedTransaction)
-            
-            return transaction
-        } catch {
-            throw error
-        }
+    public func fetchTxidsWithMemoContaining(searchTerm: String) async throws -> [Data] {
+        try await transactionRepository.fetchTxidsWithMemoContaining(searchTerm: searchTerm)
     }
-
+    
     public func allReceivedTransactions() async throws -> [ZcashTransaction.Overview] {
-        try await transactionRepository.findReceived(offset: 0, limit: Int.max)
+        try await enhanceRawTransactionsWithState(
+            rawTransactions: try await transactionRepository.findReceived(offset: 0, limit: Int.max)
+        )
     }
 
     public func allTransactions() async throws -> [ZcashTransaction.Overview] {
-        return try await transactionRepository.find(offset: 0, limit: Int.max, kind: .all)
+        try await enhanceRawTransactionsWithState(
+            rawTransactions: try await transactionRepository.find(offset: 0, limit: Int.max, kind: .all)
+        )
     }
 
     public func allSentTransactions() async throws -> [ZcashTransaction.Overview] {
-        return try await transactionRepository.findSent(offset: 0, limit: Int.max)
+        try await enhanceRawTransactionsWithState(
+            rawTransactions: try await transactionRepository.findSent(offset: 0, limit: Int.max)
+        )
     }
 
     public func allTransactions(from transaction: ZcashTransaction.Overview, limit: Int) async throws -> [ZcashTransaction.Overview] {
-        return try await transactionRepository.find(from: transaction, limit: limit, kind: .all)
+        try await enhanceRawTransactionsWithState(
+            rawTransactions: try await transactionRepository.find(from: transaction, limit: limit, kind: .all)
+        )
+    }
+    
+    private func enhanceRawTransactionsWithState(rawTransactions: [ZcashTransaction.Overview]) async throws -> [ZcashTransaction.Overview] {
+        var latestKnownBlockHeight = await latestBlocksDataProvider.latestBlockHeight
+        if latestKnownBlockHeight == 0 {
+            latestKnownBlockHeight = try await initializer.rustBackend.maxScannedHeight() ?? .zero
+        }
+        
+        return rawTransactions.map { rawTransaction in
+            var copyOfRawTransaction = rawTransaction
+            
+            copyOfRawTransaction.state = rawTransaction.getState(for: latestKnownBlockHeight)
+            
+            return copyOfRawTransaction
+        }
     }
 
     public func paginatedTransactions(of kind: TransactionKind = .all) -> PaginatedTransactionRepository {
@@ -502,7 +595,7 @@ public class SDKSynchronizer: Synchronizer {
     }
 
     public func latestHeight() async throws -> BlockHeight {
-        try await blockProcessor.latestHeight()
+        try await blockProcessor.latestHeight(mode: await sdkFlags.ifTor(.torInGroup("SDKSynchronizer.latestHeight")))
     }
 
     public func refreshUTXOs(address: TransparentAddress, from height: BlockHeight) async throws -> RefreshedUTXOs {
@@ -510,55 +603,65 @@ public class SDKSynchronizer: Synchronizer {
         return try await blockProcessor.refreshUTXOs(tAddress: address, startHeight: height)
     }
 
-    public func getAccountBalance(accountIndex: Int = 0) async throws -> AccountBalance? {
-        try await initializer.rustBackend.getWalletSummary()?.accountBalances[UInt32(accountIndex)]
+    public func getAccountsBalances() async throws -> [AccountUUID: AccountBalance] {
+        try await initializer.rustBackend.getWalletSummary()?.accountBalances ?? [:]
     }
 
     /// Fetches the latest ZEC-USD exchange rate.
     public func refreshExchangeRateUSD() {
-        // ignore refresh request when one is already in flight
-        if let latestState = tor?.cachedFiatCurrencyResult?.state, latestState == .fetching {
-            return
-        }
-        
-        // broadcast cached value but update the state
-        if let cachedFiatCurrencyResult = tor?.cachedFiatCurrencyResult {
-            var fetchingState = cachedFiatCurrencyResult
-            fetchingState.state = .fetching
-            tor?.cachedFiatCurrencyResult = fetchingState
-            
-            exchangeRateUSDSubject.send(fetchingState)
-        }
-
         Task {
+            // ignore when Tor is not enabled
+            guard await sdkFlags.exchangeRateEnabled else {
+                return
+            }
+            
+            // ignore refresh request when one is already in flight
+            if let latestState = await exchangeRateTor?.cachedFiatCurrencyResult?.state, latestState == .fetching {
+                return
+            }
+            
+            // broadcast cached value but update the state
+            if let cachedFiatCurrencyResult = await exchangeRateTor?.cachedFiatCurrencyResult {
+                var fetchingState = cachedFiatCurrencyResult
+                fetchingState.state = .fetching
+                await exchangeRateTor?.updateCachedFiatCurrencyResult(fetchingState)
+                
+                exchangeRateUSDSubject.send(fetchingState)
+            }
+            
             do {
-                if tor == nil {
+                if exchangeRateTor == nil {
                     logger.info("Bootstrapping Tor client for fetching exchange rates")
-                    tor = try await TorClient(torDir: initializer.torDirURL)
+                    let torClient = initializer.container.resolve(TorClient.self)
+                    exchangeRateTor = try await torClient.isolatedClient()
                 }
                 // broadcast new value in case of success
-                exchangeRateUSDSubject.send(try await tor?.getExchangeRateUSD())
+                exchangeRateUSDSubject.send(try await exchangeRateTor?.getExchangeRateUSD())
             } catch {
                 // broadcast cached value but update the state
-                var errorState = tor?.cachedFiatCurrencyResult
+                var errorState = await exchangeRateTor?.cachedFiatCurrencyResult
                 errorState?.state = .error
-                tor?.cachedFiatCurrencyResult = errorState
-
+                await exchangeRateTor?.updateCachedFiatCurrencyResult(errorState)
+                
                 exchangeRateUSDSubject.send(errorState)
             }
         }
     }
 
-    public func getUnifiedAddress(accountIndex: Int) async throws -> UnifiedAddress {
-        try await blockProcessor.getUnifiedAddress(accountIndex: accountIndex)
+    public func getUnifiedAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress {
+        try await blockProcessor.getUnifiedAddress(accountUUID: accountUUID)
+    }
+
+    public func getSaplingAddress(accountUUID: AccountUUID) async throws -> SaplingAddress {
+        try await blockProcessor.getSaplingAddress(accountUUID: accountUUID)
     }
 
-    public func getSaplingAddress(accountIndex: Int) async throws -> SaplingAddress {
-        try await blockProcessor.getSaplingAddress(accountIndex: accountIndex)
+    public func getTransparentAddress(accountUUID: AccountUUID) async throws -> TransparentAddress {
+        try await blockProcessor.getTransparentAddress(accountUUID: accountUUID)
     }
 
-    public func getTransparentAddress(accountIndex: Int) async throws -> TransparentAddress {
-        try await blockProcessor.getTransparentAddress(accountIndex: accountIndex)
+    public func getCustomUnifiedAddress(accountUUID: AccountUUID, receivers: Set<ReceiverType>) async throws -> UnifiedAddress {
+        try await blockProcessor.getCustomUnifiedAddress(accountUUID: accountUUID, receivers: receivers)
     }
 
     // MARK: Rewind
@@ -660,9 +763,9 @@ public class SDKSynchronizer: Synchronizer {
     ///    - nBlocksToFetch: The number of blocks expected to be downloaded from the stream, with the time compared to `fetchThresholdSeconds`. The default is 100.
     ///    - kServers: The expected number of endpoints in the output. The default is 3.
     ///    - network: Mainnet or testnet. The default is mainnet.
+    // swiftlint:disable:next cyclomatic_complexity
     public func evaluateBestOf(
         endpoints: [LightWalletEndpoint],
-        latencyThresholdMillis: Double = 300.0,
         fetchThresholdSeconds: Double = 60.0,
         nBlocksToFetch: UInt64 = 100,
         kServers: Int = 3,
@@ -685,31 +788,33 @@ public class SDKSynchronizer: Synchronizer {
             var blockTime: TimeInterval
         }
         
+        let torClient = initializer.container.resolve(TorClient.self)
+        
         // Initialize services for the endpoints
         let services = endpoints.map {
             Service(
                 originalEndpoint: $0,
-                service: LightWalletGRPCService(
-                    host: $0.host,
-                    port: $0.port,
-                    secure: $0.secure,
-                    singleCallTimeout: 5000,
-                    streamingCallTimeout: Int64(fetchThresholdSeconds) * 1000
-                ),
+                service: LightWalletGRPCServiceOverTor(endpoint: $0, tor: torClient),
                 url: "\($0.host):\($0.port)"
             )
         }
 
         // Parallel part
         var checkResults: [String: CheckResult] = [:]
+        let sdkFlagsRef = sdkFlags
         
         await withTaskGroup(of: CheckResult.self) { group in
             for service in services {
                 group.addTask {
                     let startTime = Date().timeIntervalSince1970
-                    let info = try? await service.service.getInfo()
+
+                    // called when performance of servers is evaluated
+                    let mode = await sdkFlagsRef.ifTor(ServiceMode.torInGroup("SDKSynchronizer.evaluateBestOf(\(service.originalEndpoint))"))
+
+                    let info = try? await service.service.getInfo(mode: mode)
                     let markTime = Date().timeIntervalSince1970
-                    let latestBlockHeight = try? await service.service.latestBlockHeight()
+                    // called when performance of servers is evaluated
+                    let latestBlockHeight = try? await service.service.latestBlockHeight(mode: mode)
                     let endTime = Date().timeIntervalSince1970
 
                     let getInfoTime = markTime - startTime
@@ -738,7 +843,7 @@ public class SDKSynchronizer: Synchronizer {
                 }
                 
                 // rule out if mismatch of networks
-                guard (info.chainName == "main" && network == .mainnet) 
+                guard (info.chainName == "main" && network == .mainnet)
                     || (info.chainName == "test" && network == .testnet) else {
                     continue
                 }
@@ -767,20 +872,15 @@ public class SDKSynchronizer: Synchronizer {
                 tmpResults[result.id] = result
             }
 
-            // rule out all means above latencyThreshold
-            let underThreshold = tmpResults.compactMap {
-                $0.value.mean < (latencyThresholdMillis / 1000.0) ? $0 : nil
-            }
-
             // sort the server responses by mean
-            let sortedUnderThreshold = underThreshold.sorted {
+            let sortedCheckResults = tmpResults.sorted {
                 $0.value.mean < $1.value.mean
             }
 
-            // retain only k servers
-            let sortedUnderThresholdKOnly = sortedUnderThreshold.prefix(3)
+            // retain k servers
+            let sortedKOnly = sortedCheckResults.prefix(kServers)
 
-            sortedUnderThresholdKOnly.forEach {
+            sortedKOnly.forEach {
                 checkResults[$0.key] = $0.value
             }
         }
@@ -798,10 +898,15 @@ public class SDKSynchronizer: Synchronizer {
             guard info.blockHeight >= nBlocksToFetch else {
                 continue
             }
-            
-            let stream = service.service.blockStream(startHeight: BlockHeight(info.blockHeight - nBlocksToFetch), endHeight: BlockHeight(info.blockHeight))
-            
+
             do {
+                // Fetched the same way as in `BlockDownloader`.
+                let stream = try service.service.blockStream(
+                    startHeight: BlockHeight(info.blockHeight - nBlocksToFetch),
+                    endHeight: BlockHeight(info.blockHeight),
+                    mode: .direct
+                )
+
                 let startTime = Date().timeIntervalSince1970
                 var endTime = startTime
                 for try await _ in stream {
@@ -837,6 +942,130 @@ public class SDKSynchronizer: Synchronizer {
         return finalResult
     }
     
+    public func estimateBirthdayHeight(for date: Date) -> BlockHeight {
+        initializer.container.resolve(CheckpointSource.self).estimateBirthdayHeight(for: date)
+    }
+
+    public func tor(enabled: Bool) async throws {
+        let isExchangeRateEnabled = await sdkFlags.exchangeRateEnabled
+
+        // turn Tor on
+        if enabled && !isExchangeRateEnabled {
+            try await enableAndStartupTorClient()
+        }
+
+        // turn Tor off
+        if !enabled && !isExchangeRateEnabled {
+            try await disableAndCleanupTorClients()
+        }
+
+        await sdkFlags.torFlagUpdate(enabled)
+    }
+
+    public func exchangeRateOverTor(enabled: Bool) async throws {
+        let isTorEnabled = await sdkFlags.torEnabled
+
+        // turn Tor on
+        if enabled && !isTorEnabled {
+            try await enableAndStartupTorClient()
+        }
+
+        // turn Tor off
+        if !enabled && !isTorEnabled {
+            try await disableAndCleanupTorClients()
+        }
+
+        await sdkFlags.exchangeRateFlagUpdate(enabled)
+    }
+    
+    private func enableAndStartupTorClient() async throws {
+        let torClient = initializer.container.resolve(TorClient.self)
+        try await torClient.prepare()
+    }
+    
+    private func disableAndCleanupTorClients() async throws {
+        await sdkFlags.torClientInitializationSuccessfullyDoneFlagUpdate(nil)
+
+        // case when previous was enabled and newly is required to be stopped
+        let torClient = initializer.container.resolve(TorClient.self)
+        // close of the initial TorClient, it's used for creation of isolated clients
+        try await torClient.close()
+        // deinit of isolated TorClient used for fetching exchange rates
+        exchangeRateTor = nil
+        // deinit of isolated TorClient used for http requests
+        httpTor = nil
+        // close all connections
+        let lwdService = initializer.container.resolve(LightWalletService.self)
+        await lwdService.closeConnections()
+    }
+    
+    public func isTorSuccessfullyInitialized() async -> Bool? {
+        await sdkFlags.torClientInitializationSuccessfullyDone
+    }
+
+    public func httpRequestOverTor(for request: URLRequest, retryLimit: UInt8 = 3) async throws -> (data: Data, response: HTTPURLResponse) {
+        guard await sdkFlags.torEnabled else {
+            throw ZcashError.torNotEnabled
+        }
+        
+        if httpTor == nil {
+            logger.info("Bootstrapping Tor client for making http requests")
+            if let torService = initializer.container.resolve(LightWalletService.self) as? LightWalletGRPCServiceOverTor {
+                httpTor = try await torService.tor.isolatedClient()
+            }
+        }
+        
+        guard let httpTor else {
+            throw ZcashError.torClientUnavailable
+        }
+        
+        return try await httpTor.isolatedClient().httpRequest(for: request, retryLimit: retryLimit)
+    }
+    
+    public func debugDatabase(sql: String) -> String {
+        transactionRepository.debugDatabase(sql: sql)
+    }
+    
+    public func getSingleUseTransparentAddress(accountUUID: AccountUUID) async throws -> SingleUseTransparentAddress {
+        try await initializer.rustBackend.getSingleUseTransparentAddress(accountUUID: accountUUID)
+    }
+
+    public func checkSingleUseTransparentAddresses(accountUUID: AccountUUID) async throws -> TransparentAddressCheckResult {
+        let dbData = initializer.dataDbURL.osStr()
+        
+        return try await initializer.lightWalletService.checkSingleUseTransparentAddresses(
+            dbData: dbData,
+            networkType: network.networkType,
+            accountUUID: accountUUID,
+            mode: await sdkFlags.ifTor(.uniqueTor)
+        )
+    }
+    
+    public func updateTransparentAddressTransactions(address: String) async throws -> TransparentAddressCheckResult {
+        let dbData = initializer.dataDbURL.osStr()
+        
+        return try await initializer.lightWalletService.updateTransparentAddressTransactions(
+            address: address,
+            start: 0,
+            end: -1,
+            dbData: dbData,
+            networkType: network.networkType,
+            mode: await sdkFlags.ifTor(.uniqueTor)
+        )
+    }
+    
+    public func fetchUTXOsBy(address: String, accountUUID: AccountUUID) async throws -> TransparentAddressCheckResult {
+        let dbData = initializer.dataDbURL.osStr()
+        
+        return try await initializer.lightWalletService.fetchUTXOsByAddress(
+            address: address,
+            dbData: dbData,
+            networkType: network.networkType,
+            accountUUID: accountUUID,
+            mode: await sdkFlags.ifTor(.uniqueTor)
+        )
+    }
+
     // MARK: Server switch
 
     public func switchTo(endpoint: LightWalletEndpoint) async throws {
@@ -846,16 +1075,12 @@ public class SDKSynchronizer: Synchronizer {
             await blockProcessor.stop()
         }
 
+        let torClient = initializer.container.resolve(TorClient.self)
+        
         // Validation of the server is first because any custom endpoint can be passed here
-        // Extra instance of the service is created with lower timeout ofr a single call
+        // Extra instance of the service is created with lower timeout for a single call
         initializer.container.register(type: LightWalletService.self, isSingleton: true) { _ in
-            LightWalletGRPCService(
-                host: endpoint.host,
-                port: endpoint.port,
-                secure: endpoint.secure,
-                singleCallTimeout: 5000,
-                streamingCallTimeout: endpoint.streamingCallTimeoutInMillis
-            )
+            LightWalletGRPCServiceOverTor(endpoint: endpoint, tor: torClient, singleCallTimeout: 5000)
         }
 
         let validateSever = ValidateServerAction(
@@ -876,7 +1101,7 @@ public class SDKSynchronizer: Synchronizer {
         
         // LightWalletService dependency update
         initializer.container.register(type: LightWalletService.self, isSingleton: true) { _ in
-            LightWalletGRPCService(endpoint: endpoint)
+            LightWalletGRPCServiceOverTor(endpoint: endpoint, tor: torClient)
         }
 
         // DEPENDENCIES
@@ -893,8 +1118,9 @@ public class SDKSynchronizer: Synchronizer {
         initializer.container.register(type: LatestBlocksDataProvider.self, isSingleton: true) { di in
             let service = di.resolve(LightWalletService.self)
             let rustBackend = di.resolve(ZcashRustBackendWelding.self)
+            let sdkFlags = di.resolve(SDKFlags.self)
 
-            return LatestBlocksDataProviderImpl(service: service, rustBackend: rustBackend)
+            return LatestBlocksDataProviderImpl(service: service, rustBackend: rustBackend, sdkFlags: sdkFlags)
         }
         
         // CompactBlockProcessor dependency update
@@ -925,7 +1151,7 @@ public class SDKSynchronizer: Synchronizer {
     private func snapshotState(status: InternalSyncStatus) async -> SynchronizerState {
         await SynchronizerState(
             syncSessionID: syncSession.value,
-            accountBalance: try? await getAccountBalance(),
+            accountsBalances: (try? await getAccountsBalances()) ?? [:],
             internalSyncStatus: status,
             latestBlockHeight: latestBlocksDataProvider.latestBlockHeight
         )