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

package/ios/ZCashLightClientKit/Block/Actions/UpdateSubtreeRootsAction.swift

@@ -29,7 +29,8 @@ extension UpdateSubtreeRootsAction: Action {
         request.shieldedProtocol = .sapling
         
         logger.debug("Attempt to get subtree roots, this may fail because lightwalletd may not support Spend before Sync.")
-        let stream = service.getSubtreeRoots(request)
+        // ServiceMode to resolve
+        let stream = try service.getSubtreeRoots(request, mode: .direct)
 
         var saplingRoots: [SubtreeRoot] = []
         
@@ -59,7 +60,8 @@ extension UpdateSubtreeRootsAction: Action {
             var orchardRequest = GetSubtreeRootsArg()
             orchardRequest.shieldedProtocol = .orchard
 
-            let stream = service.getSubtreeRoots(orchardRequest)
+            // ServiceMode to resolve
+            let stream = try service.getSubtreeRoots(orchardRequest, mode: .direct)
 
             var orchardRoots: [SubtreeRoot] = []
 

package/ios/ZCashLightClientKit/Block/Actions/ValidateServerAction.swift

@@ -11,11 +11,13 @@ final class ValidateServerAction {
     let configProvider: CompactBlockProcessor.ConfigProvider
     let rustBackend: ZcashRustBackendWelding
     var service: LightWalletService
+    let sdkFlags: SDKFlags
 
     init(container: DIContainer, configProvider: CompactBlockProcessor.ConfigProvider) {
         self.configProvider = configProvider
         rustBackend = container.resolve(ZcashRustBackendWelding.self)
         service = container.resolve(LightWalletService.self)
+        sdkFlags = container.resolve(SDKFlags.self)
     }
 }
 
@@ -24,7 +26,8 @@ extension ValidateServerAction: Action {
 
     func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
         let config = await configProvider.config
-        let info = try await service.getInfo()
+        // called each sync, an action in a state machine diagram
+        let info = try await service.getInfo(mode: await sdkFlags.ifTor(.defaultTor))
         let localNetwork = config.network
         let saplingActivation = config.saplingActivation
 

package/ios/ZCashLightClientKit/Block/CompactBlockProcessor.swift

@@ -20,6 +20,7 @@ actor CompactBlockProcessor {
     private var eventClosures: [String: EventClosure] = [:]
 
     private var syncTask: Task<Void, Error>?
+    private var mempoolDetectionTask: Task<Void, Error>?
 
     private let actions: [CBPState: Action]
     var context: ActionContext
@@ -67,7 +68,7 @@ actor CompactBlockProcessor {
         let rewindDistance: Int
         let walletBirthdayProvider: () -> BlockHeight
         var walletBirthday: BlockHeight { walletBirthdayProvider() }
-        let downloadBufferSize: Int = 10
+        let downloadBufferSize: Int = 100
         let network: ZcashNetwork
         let saplingActivation: BlockHeight
         let cacheDbURL: URL?
@@ -201,6 +202,8 @@ actor CompactBlockProcessor {
     deinit {
         syncTask?.cancel()
         syncTask = nil
+        mempoolDetectionTask?.cancel()
+        mempoolDetectionTask = nil
     }
 
     // swiftlint:disable:next cyclomatic_complexity
@@ -278,10 +281,15 @@ extension CompactBlockProcessor {
         syncTask = Task(priority: .userInitiated) {
             await run()
         }
+        
+        mempoolDetectionTask = Task {
+            await watchMempool()
+        }
     }
 
     func stop() async {
         syncTask?.cancel()
+        mempoolDetectionTask?.cancel()
         self.backoffTimer?.invalidate()
         self.backoffTimer = nil
         await stopAllActions()
@@ -289,8 +297,8 @@ extension CompactBlockProcessor {
         serviceFailureRetryAttempts = 0
     }
 
-    func latestHeight() async throws -> BlockHeight {
-        try await blockDownloaderService.latestBlockHeight()
+    func latestHeight(mode: ServiceMode) async throws -> BlockHeight {
+        try await blockDownloaderService.latestBlockHeight(mode: mode)
     }
     
     func consensusBranchIdFor(_ height: Int32) -> Int32? {
@@ -367,6 +375,55 @@ private extension CompactBlockProcessor {
     }
 }
 
+// MARK: - Mempool Detection
+
+extension CompactBlockProcessor {
+    func watchMempool() async {
+        while !Task.isCancelled {
+            do {
+                try await consumeMempoolStream()
+                
+                try await Task.sleep(nanoseconds: 500_000_000)
+            } catch {
+                // Connection hammering prevention, wait 30s in case stream failed
+                try? await Task.sleep(nanoseconds: 30_000_000_000)
+            }
+        }
+    }
+    
+    func consumeMempoolStream() async throws {
+        let stream = try service.getMempoolStream()
+        
+        do {
+            for try await rawTransaction in stream {
+                let mempoolTransactions = try await resolveMempools(rawTransaction: rawTransaction)
+                
+                if !mempoolTransactions.isEmpty {
+                    let height = BlockHeight(rawTransaction.height)
+                    await send(event: .foundTransactions(mempoolTransactions, .init(uncheckedBounds: (lower: height, upper: height))))
+                }
+            }
+        } catch { }
+    }
+    
+    @DBActor
+    func resolveMempools(rawTransaction: RawTransaction) async throws -> [ZcashTransaction.Overview] {
+        let minedHeight = (rawTransaction.height == 0 || rawTransaction.height > UInt32.max)
+        ? nil : UInt32(rawTransaction.height)
+        
+        let txIdData = try await rustBackend.decryptAndStoreTransaction(
+            txBytes: rawTransaction.data.bytes,
+            minedHeight: minedHeight
+        )
+
+        if let transaction = try? await transactionRepository.find(rawID: txIdData) {
+            return [transaction]
+        }
+        
+        return []
+    }
+}
+
 // MARK: - Wipe
 
 extension CompactBlockProcessor {
@@ -374,6 +431,8 @@ extension CompactBlockProcessor {
         logger.debug("Starting wipe")
         if await isIdle() {
             logger.debug("Sync doesn't run. Executing wipe.")
+            self.backoffTimer?.invalidate()
+            self.backoffTimer = nil
             try await doWipe(context: context)
         } else {
             logger.debug("Stopping sync because of wipe")
@@ -483,10 +542,10 @@ extension CompactBlockProcessor {
         case handledReorg(_ reorgHeight: BlockHeight, _ rewindHeight: BlockHeight)
 
         /// Event sent when progress of some specific action happened.
-        case syncProgress(Float)
+        case syncProgress(Float, Bool)
 
         /// Event sent when progress of the sync process changes.
-        case progressUpdated(Float)
+        case progressUpdated(Float, Bool)
 
         /// Event sent when the CompactBlockProcessor fetched utxos from lightwalletd attempted to store them.
         case storedUTXOs((inserted: [UnspentTransactionOutputEntity], skipped: [UnspentTransactionOutputEntity]))
@@ -569,7 +628,9 @@ extension CompactBlockProcessor {
                     await self?.send(event: event)
                     if let progressChanged = await self?.compactBlockProgress.hasProgressUpdated(event), progressChanged {
                         if let progress = await self?.compactBlockProgress.progress {
-                            await self?.send(event: .progressUpdated(progress))
+                            await self?.send(
+                                event: .progressUpdated(progress, self?.compactBlockProgress.areFundsSpendable ?? false)
+                            )
                         }
                     }
                 }
@@ -713,7 +774,7 @@ extension CompactBlockProcessor {
         let lastScannedHeight = await latestBlocksDataProvider.maxScannedHeight
         // Some actions may not run. For example there are no transactions to enhance and therefore there is no enhance progress. And in
         // cases like this computation of final progress won't work properly. So let's fake 100% progress at the end of the sync process.
-        await send(event: .progressUpdated(1))
+        await send(event: .progressUpdated(1, false))
         await send(event: .finished(lastScannedHeight))
         await context.update(state: .finished)
 
@@ -776,7 +837,7 @@ extension CompactBlockProcessor {
                     guard let self else { return }
                     if await self.isIdle() {
                         if await self.canStartSync() {
-                            self.logger.debug(
+                            await self.logger.debug(
                                 """
                                 Timer triggered: Starting compact Block processor!.
                                 Processor State: \(await self.context.state)
@@ -837,16 +898,20 @@ extension CompactBlockProcessor {
 }
 
 extension CompactBlockProcessor {
-    func getUnifiedAddress(accountIndex: Int) async throws -> UnifiedAddress {
-        try await rustBackend.getCurrentAddress(account: Int32(accountIndex))
+    func getUnifiedAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress {
+        try await rustBackend.getCurrentAddress(accountUUID: accountUUID)
     }
     
-    func getSaplingAddress(accountIndex: Int) async throws -> SaplingAddress {
-        try await getUnifiedAddress(accountIndex: accountIndex).saplingReceiver()
+    func getSaplingAddress(accountUUID: AccountUUID) async throws -> SaplingAddress {
+        try await getUnifiedAddress(accountUUID: accountUUID).saplingReceiver()
     }
     
-    func getTransparentAddress(accountIndex: Int) async throws -> TransparentAddress {
-        try await getUnifiedAddress(accountIndex: accountIndex).transparentReceiver()
+    func getTransparentAddress(accountUUID: AccountUUID) async throws -> TransparentAddress {
+        try await getUnifiedAddress(accountUUID: accountUUID).transparentReceiver()
+    }
+
+    func getCustomUnifiedAddress(accountUUID: AccountUUID, receivers: Set<ReceiverType>) async throws -> UnifiedAddress {
+        try await rustBackend.getNextAvailableAddress(accountUUID: accountUUID, receiverFlags: receivers.toFlags())
     }
 }
 
@@ -854,9 +919,11 @@ extension CompactBlockProcessor {
     func refreshUTXOs(tAddress: TransparentAddress, startHeight: BlockHeight) async throws -> RefreshedUTXOs {
         let dataDb = self.config.dataDb
         
-        let stream: AsyncThrowingStream<UnspentTransactionOutputEntity, Error> = blockDownloaderService.fetchUnspentTransactionOutputs(
+        // ServiceMode to resolve
+        let stream: AsyncThrowingStream<UnspentTransactionOutputEntity, Error> = try blockDownloaderService.fetchUnspentTransactionOutputs(
             tAddress: tAddress.stringEncoded,
-            startHeight: startHeight
+            startHeight: startHeight,
+            mode: .direct
         )
         var utxos: [UnspentTransactionOutputEntity] = []
         

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

@@ -135,7 +135,8 @@ actor BlockDownloaderImpl {
                 logger.debug("Creating new stream for range \(streamRange.lowerBound)...\(streamRange.upperBound)")
 
                 downloadStreamCreatedAtRange = streamRange
-                let stream = service.blockStream(startHeight: streamRange.lowerBound, endHeight: streamRange.upperBound)
+                // ServiceMode to resolve
+                let stream = try service.blockStream(startHeight: streamRange.lowerBound, endHeight: streamRange.upperBound, mode: .direct)
                 downloadStream = BlockDownloaderStream(stream: stream)
                 self.downloadStream = downloadStream
             }
@@ -182,7 +183,8 @@ actor BlockDownloaderImpl {
 
     private func compactBlocksDownloadStream(startHeight: BlockHeight, targetHeight: BlockHeight) async throws -> BlockDownloaderStream {
         try Task.checkCancellation()
-        let stream = service.blockStream(startHeight: startHeight, endHeight: targetHeight)
+        // ServiceMode to resolve
+        let stream = try service.blockStream(startHeight: startHeight, endHeight: targetHeight, mode: .direct)
         return BlockDownloaderStream(stream: stream)
     }
 

package/ios/ZCashLightClientKit/Block/Download/BlockDownloaderService.swift

@@ -21,7 +21,7 @@ protocol BlockDownloaderService {
     /**
     Downloads and stores the given block range.
     */
-    func downloadBlockRange(_ heightRange: CompactBlockRange) async throws
+    func downloadBlockRange(_ heightRange: CompactBlockRange, mode: ServiceMode) async throws
 
     /**
     Restore the download progress up to the given height.
@@ -37,19 +37,19 @@ protocol BlockDownloaderService {
     /**
     Returns the latest block height
     */
-    func latestBlockHeight() async throws -> BlockHeight
+    func latestBlockHeight(mode: ServiceMode) async throws -> BlockHeight
 
     /**
     Gets the transaction for the Id given
     - Parameter txId: Data representing the transaction Id
     */
-    func fetchTransaction(txId: Data) async throws -> (tx: ZcashTransaction.Fetched?, status: TransactionStatus)
+    func fetchTransaction(txId: Data, mode: ServiceMode) async throws -> (tx: ZcashTransaction.Fetched?, status: TransactionStatus)
 
-    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>
+    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight, mode: ServiceMode) throws -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>
 
-    func fetchUnspentTransactionOutputs(tAddresses: [String], startHeight: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>
+    func fetchUnspentTransactionOutputs(tAddresses: [String], startHeight: BlockHeight, mode: ServiceMode) throws -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>
     
-    func closeConnection()
+    func closeConnections()
 }
 
 /**
@@ -71,27 +71,30 @@ class BlockDownloaderServiceImpl {
 }
 
 extension BlockDownloaderServiceImpl: BlockDownloaderService {
-    func closeConnection() {
-        lightwalletService.closeConnection()
+    func closeConnections() {
+        Task {
+            await lightwalletService.closeConnections()
+        }
     }
             
     func fetchUnspentTransactionOutputs(
         tAddresses: [String],
-        startHeight: BlockHeight
-    ) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
-        lightwalletService.fetchUTXOs(for: tAddresses, height: startHeight)
+        startHeight: BlockHeight,
+        mode: ServiceMode
+    ) throws -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
+        try lightwalletService.fetchUTXOs(for: tAddresses, height: startHeight, mode: mode)
     }
     
-    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
-        lightwalletService.fetchUTXOs(for: tAddress, height: startHeight)
+    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight, mode: ServiceMode) throws -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
+        try lightwalletService.fetchUTXOs(for: tAddress, height: startHeight, mode: mode)
     }
     
-    func latestBlockHeight() async throws -> BlockHeight {
-        try await lightwalletService.latestBlockHeight()
+    func latestBlockHeight(mode: ServiceMode) async throws -> BlockHeight {
+        try await lightwalletService.latestBlockHeight(mode: mode)
     }
     
-    func downloadBlockRange( _ heightRange: CompactBlockRange) async throws {
-        let stream: AsyncThrowingStream<ZcashCompactBlock, Error> = lightwalletService.blockRange(heightRange)
+    func downloadBlockRange( _ heightRange: CompactBlockRange, mode: ServiceMode) async throws {
+        let stream: AsyncThrowingStream<ZcashCompactBlock, Error> = try lightwalletService.blockRange(heightRange, mode: mode)
         do {
             var compactBlocks: [ZcashCompactBlock] = []
             for try await compactBlock in stream {
@@ -111,7 +114,7 @@ extension BlockDownloaderServiceImpl: BlockDownloaderService {
         try await self.storage.latestHeight()
     }
     
-    func fetchTransaction(txId: Data) async throws -> (tx: ZcashTransaction.Fetched?, status: TransactionStatus) {
-        try await lightwalletService.fetchTransaction(txId: txId)
+    func fetchTransaction(txId: Data, mode: ServiceMode) async throws -> (tx: ZcashTransaction.Fetched?, status: TransactionStatus) {
+        try await lightwalletService.fetchTransaction(txId: txId, mode: mode)
     }
 }

package/ios/ZCashLightClientKit/Block/Enhance/BlockEnhancer.swift

@@ -62,17 +62,16 @@ struct BlockEnhancerImpl {
     let metrics: SDKMetrics
     let service: LightWalletService
     let logger: Logger
+    let sdkFlags: SDKFlags
 }
 
 extension BlockEnhancerImpl: BlockEnhancer {
+    // swiftlint:disable:next cyclomatic_complexity
     func enhance(at range: CompactBlockRange, didEnhance: @escaping (EnhancementProgress) async -> Void) async throws -> [ZcashTransaction.Overview]? {
         try Task.checkCancellation()
         
         logger.debug("Started Enhancing range: \(range)")
 
-        var retries = 0
-        let maxRetries = 5
-        
         // fetch transactions
         do {
             let transactionDataRequests = try await rustBackend.transactionDataRequests()
@@ -86,49 +85,84 @@ extension BlockEnhancerImpl: BlockEnhancer {
             for index in 0 ..< transactionDataRequests.count {
                 let transactionDataRequest = transactionDataRequests[index]
                 var retry = true
+                var retries = 0
+                let maxRetries = 5
 
                 while retry && retries < maxRetries {
                     try Task.checkCancellation()
                     do {
                         switch transactionDataRequest {
                         case .getStatus(let txId):
-                            let response = try await blockDownloaderService.fetchTransaction(txId: txId.data)
+                            let response = try await blockDownloaderService.fetchTransaction(
+                                txId: txId.data,
+                                mode: await sdkFlags.ifTor(ServiceMode.txIdGroup(prefix: "fetch", txId: txId.data))
+                            )
                             retry = false
 
-                            if let fetchedTransaction = response.tx {
+                            if response.status == .txidNotRecognized {
+                                try await rustBackend.setTransactionStatus(txId: txId.data, status: response.status)
+                            } else if let fetchedTransaction = response.tx {
                                 try await rustBackend.setTransactionStatus(txId: fetchedTransaction.rawID, status: response.status)
                             }
                             
                         case .enhancement(let txId):
-                            let response = try await blockDownloaderService.fetchTransaction(txId: txId.data)
+                            let response = try await blockDownloaderService.fetchTransaction(
+                                txId: txId.data,
+                                mode: await sdkFlags.ifTor(ServiceMode.txIdGroup(prefix: "fetch", txId: txId.data))
+                            )
                             retry = false
 
                             if response.status == .txidNotRecognized {
                                 try await rustBackend.setTransactionStatus(txId: txId.data, status: .txidNotRecognized)
                             } else if let fetchedTransaction = response.tx {
-                                try await rustBackend.decryptAndStoreTransaction(
+                                _ = try await rustBackend.decryptAndStoreTransaction(
                                     txBytes: fetchedTransaction.raw.bytes,
                                     minedHeight: fetchedTransaction.minedHeight
                                 )
                             }
 
-                        case .spendsFromAddress(let sfa):
-                            guard let blockRangeEnd = sfa.blockRangeEnd else {
-                                logger.error("spendsFromAddress \(sfa) is missing blockRangeEnd, ignoring the request.")
+                        case .transactionsInvolvingAddress(let tia):
+                            // TODO: [#1554] Remove this guard once lightwalletd servers support open-ended ranges.
+                            guard tia.blockRangeEnd != nil else {
+                                logger.error("transactionsInvolvingAddress \(tia) is missing blockRangeEnd, ignoring the request.")
+                                retry = false
                                 continue
                             }
-                            
+
+                            // TODO: [#1551] Support this.
+                            if tia.requestAt != nil {
+                                logger.error("transactionsInvolvingAddress \(tia) has requestAt set, ignoring the unsupported request.")
+                                retry = false
+                                continue
+                            }
+
+                            // TODO: [#1552] Support the OutputStatusFilter
+                            if tia.outputStatusFilter == .unspent {
+                                retry = false
+                                continue
+                            }
+
                             var filter = TransparentAddressBlockFilter()
-                            filter.address = sfa.address
-                            filter.range = BlockRange(startHeight: Int(sfa.blockRangeStart), endHeight: Int(blockRangeEnd - 1))
+                            filter.address = tia.address
+                            filter.range = if let blockRangeEnd = tia.blockRangeEnd {
+                                BlockRange(startHeight: Int(tia.blockRangeStart), endHeight: Int(blockRangeEnd - 1))
+                            } else {
+                                BlockRange(startHeight: Int(tia.blockRangeStart))
+                            }
 
-                            let stream = service.getTaddressTxids(filter)
+                            // ServiceMode to resolve
+                            let stream = try service.getTaddressTxids(filter, mode: .direct)
 
                             for try await rawTransaction in stream {
-                                let minedHeight = (rawTransaction.height == 0 || rawTransaction.height > UInt32.max) 
+                                let minedHeight = (rawTransaction.height == 0 || rawTransaction.height > UInt32.max)
                                 ? nil : UInt32(rawTransaction.height)
 
-                                try await rustBackend.decryptAndStoreTransaction(
+                                // Ignore transactions that don't match the status filter.
+                                if (tia.txStatusFilter == .mined && minedHeight == nil) || (tia.txStatusFilter == .mempool && minedHeight != nil) {
+                                    continue
+                                }
+
+                                _ = try await rustBackend.decryptAndStoreTransaction(
                                     txBytes: rawTransaction.data.bytes,
                                     minedHeight: minedHeight
                                 )
@@ -138,9 +172,6 @@ extension BlockEnhancerImpl: BlockEnhancer {
                     } catch {
                         retries += 1
                         logger.error("could not enhance transactionDataRequest \(transactionDataRequest) - Error: \(error)")
-                        if retries > maxRetries {
-                            throw error
-                        }
                     }
                 }
             }

package/ios/ZCashLightClientKit/Block/FetchUnspentTxOutputs/UTXOFetcher.swift

@@ -40,13 +40,15 @@ extension UTXOFetcherImpl: UTXOFetcher {
 
         var tAddresses: [TransparentAddress] = []
         for account in accounts {
-            tAddresses += try await rustBackend.listTransparentReceivers(account: Int32(account))
+            tAddresses += try await rustBackend.listTransparentReceivers(accountUUID: account.id)
         }
 
         var utxos: [UnspentTransactionOutputEntity] = []
-        let stream: AsyncThrowingStream<UnspentTransactionOutputEntity, Error> = blockDownloaderService.fetchUnspentTransactionOutputs(
+        // ServiceMode to resolve
+        let stream: AsyncThrowingStream<UnspentTransactionOutputEntity, Error> = try blockDownloaderService.fetchUnspentTransactionOutputs(
             tAddresses: tAddresses.map { $0.stringEncoded },
-            startHeight: await config.walletBirthdayProvider()
+            startHeight: BlockHeight(0),
+            mode: .direct
         )
 
         do {

package/ios/ZCashLightClientKit/Block/SaplingParameters/SaplingParametersHandler.swift

@@ -28,13 +28,30 @@ extension SaplingParametersHandlerImpl: SaplingParametersHandler {
         try Task.checkCancellation()
 
         do {
-            let totalSaplingBalance =
-                try await rustBackend.getWalletSummary()?.accountBalances[0]?.saplingBalance.total().amount
-                ?? 0
-            let totalTransparentBalance = try await rustBackend.getTransparentBalance(account: Int32(0))
+            let accounts = try await rustBackend.listAccounts()
 
+            var totalSaplingBalanceTrigger = false
+            var totalTransparentBalanceTrigger = false
+            let accountBalances = try await rustBackend.getWalletSummary()?.accountBalances
+            
+            for account in accounts {
+                let totalSaplingBalance = accountBalances?[account.id]?.saplingBalance.total().amount ?? 0
+
+                if totalSaplingBalance > 0 {
+                    totalSaplingBalanceTrigger = true
+                    break
+                }
+
+                let totalTransparentBalance = try await rustBackend.getTransparentBalance(accountUUID: account.id)
+
+                if totalTransparentBalance > 0 {
+                    totalTransparentBalanceTrigger = true
+                    break
+                }
+            }
+            
             // Download Sapling parameters only if sapling funds are detected.
-            guard totalSaplingBalance > 0 || totalTransparentBalance > 0 else { return }
+            guard totalSaplingBalanceTrigger || totalTransparentBalanceTrigger else { return }
         } catch {
             // if sapling balance can't be detected of we fail to obtain the balance
             // for some reason we shall not proceed to download the parameters and

package/ios/ZCashLightClientKit/Block/Scan/BlockScanner.swift

@@ -57,7 +57,8 @@ extension BlockScannerImpl: BlockScanner {
             let scanSummary: ScanSummary
             let scanStartTime = Date()
             do {
-                let fromState = try await service.getTreeState(BlockID(height: startHeight - 1))
+                // Directly correlated with `BlockDownloader` ranges.
+                let fromState = try await service.getTreeState(BlockID(height: startHeight - 1), mode: .direct)
 
                 scanSummary = try await self.rustBackend.scanBlocks(fromHeight: Int32(startHeight), fromState: fromState, limit: batchSize)
             } catch {

package/ios/ZCashLightClientKit/Block/Utils/CompactBlockProgress.swift

@@ -11,14 +11,16 @@ final actor CompactBlockProgress {
     static let zero = CompactBlockProgress()
 
     var progress: Float = 0.0
+    var areFundsSpendable = false
 
     func hasProgressUpdated(_ event: CompactBlockProcessor.Event) -> Bool {
-        guard case .syncProgress(let update) = event else {
+        guard case let .syncProgress(progress, areFundsSpendable) = event else {
             return false
         }
 
-        progress = update
-        
+        self.progress = progress
+        self.areFundsSpendable = areFundsSpendable
+
         return true
     }
 }

package/ios/ZCashLightClientKit/Checkpoint/BundleCheckpointSource.swift

@@ -30,4 +30,92 @@ struct BundleCheckpointSource: CheckpointSource {
             checkpointDirectory: BundleCheckpointURLProvider.default.url(self.network)
         ) ?? saplingActivation
     }
+    
+    // swiftlint:disable:next cyclomatic_complexity
+    func estimateBirthdayHeight(for date: Date) -> BlockHeight {
+        // the average time between 2500 blocks during last 10 checkpoints (estimated March 31, 2025) is 52.33 hours for mainnet
+        // the average time between 10,000 blocks during last 10 checkpoints (estimated March 31, 2025) is 134.93 hours for testnet
+        let avgIntervalTime: TimeInterval = network == .mainnet ? 52.33 : 134.93
+        let blockInterval: Double = network == .mainnet ? 2500 : 10_000
+        let saplingActivationHeight = network == .mainnet
+        ? ZcashMainnet().constants.saplingActivationHeight
+        : ZcashTestnet().constants.saplingActivationHeight
+
+        let latestCheckpoint = latestKnownCheckpoint()
+        let latestCheckpointTime = TimeInterval(latestCheckpoint.time)
+
+        // above latest checkpoint, return it
+        guard date.timeIntervalSince1970 < latestCheckpointTime else {
+            return latestCheckpoint.height
+        }
+        
+        // Phase 1, estimate possible height
+        let nowTimeIntervalSince1970 = Date().timeIntervalSince1970
+        let timeDiff = (nowTimeIntervalSince1970 - date.timeIntervalSince1970) - (nowTimeIntervalSince1970 - latestCheckpointTime)
+        let blockDiff = ((timeDiff / 3600) / avgIntervalTime) * blockInterval
+
+        var heightToLookAround = Double(Int(latestCheckpoint.height - Int(blockDiff)) / Int(blockInterval)) * blockInterval
+
+        // bellow sapling activation height
+        guard Int(heightToLookAround) > saplingActivationHeight else {
+            return saplingActivationHeight
+        }
+        
+        // Phase 2, load checkpoint and evaluate against given date
+        guard let loadedCheckpoint = Checkpoint.birthday(
+            with: BlockHeight(heightToLookAround),
+            checkpointDirectory: BundleCheckpointURLProvider.default.url(self.network)
+        ) else {
+            return saplingActivationHeight
+        }
+
+        // loaded checkpoint is exactly the one
+        var hoursApart = (TimeInterval(loadedCheckpoint.time) - date.timeIntervalSince1970) / 3600
+        if hoursApart < 0 && abs(hoursApart) < avgIntervalTime {
+            return loadedCheckpoint.height
+        }
+        
+        if hoursApart < 0 {
+            // loaded checkpoint is lower, increase until reached the one
+            var closestHeight = loadedCheckpoint.height
+            while abs(hoursApart) > avgIntervalTime {
+                heightToLookAround += blockInterval
+                
+                if let loadedCheckpoint = Checkpoint.birthday(
+                    with: BlockHeight(heightToLookAround),
+                    checkpointDirectory: BundleCheckpointURLProvider.default.url(self.network)
+                ) {
+                    hoursApart = (TimeInterval(loadedCheckpoint.time) - date.timeIntervalSince1970) / 3600
+                    if hoursApart < 0 && abs(hoursApart) < avgIntervalTime {
+                        return loadedCheckpoint.height
+                    } else if hoursApart >= 0 {
+                        return closestHeight
+                    }
+
+                    closestHeight = loadedCheckpoint.height
+                } else {
+                    return saplingActivationHeight
+                }
+            }
+        } else {
+            // loaded checkpoint is higher, descrease until reached the one
+            while hoursApart > 0 {
+                heightToLookAround -= blockInterval
+                
+                if let loadedCheckpoint = Checkpoint.birthday(
+                    with: BlockHeight(heightToLookAround),
+                    checkpointDirectory: BundleCheckpointURLProvider.default.url(self.network)
+                ) {
+                    hoursApart = (TimeInterval(loadedCheckpoint.time) - date.timeIntervalSince1970) / 3600
+                    if hoursApart < 0 {
+                        return loadedCheckpoint.height
+                    }
+                } else {
+                    return saplingActivationHeight
+                }
+            }
+        }
+
+        return saplingActivationHeight
+    }
 }