react-native-zcash 0.6.9 → 0.6.11

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

@@ -52,14 +52,6 @@ protocol BlockDownloader {
     /// called before then nothing is downloaded.
     /// - Parameter range: Wait until blocks from `range` are downloaded.
     func waitUntilRequestedBlocksAreDownloaded(in range: CompactBlockRange) async throws
-    
-    /// Updates the internal in memory value of latest downloaded block height. This way the `BlockDownloader` works with the current latest height and can
-    /// continue on parallel downloading of next batch.
-    func update(latestDownloadedBlockHeight: BlockHeight, force: Bool) async
-    /// Provides the value of latest downloaded height.
-    func latestDownloadedBlockHeight() async -> BlockHeight
-    /// In case rewind is needed, the latestDownloadedBlockHeight is rewritten forcefully.
-    func rewind(latestDownloadedBlockHeight: BlockHeight?) async
 }
 
 actor BlockDownloaderImpl {
@@ -70,9 +62,9 @@ actor BlockDownloaderImpl {
     let service: LightWalletService
     let downloaderService: BlockDownloaderService
     let storage: CompactBlockRepository
+    let internalSyncProgress: InternalSyncProgress
     let metrics: SDKMetrics
     let logger: Logger
-    var latestDownloadedBlockHeight: BlockHeight = -1
 
     private var downloadStreamCreatedAtRange: CompactBlockRange = 0...0
     private var downloadStream: BlockDownloaderStream?
@@ -88,12 +80,14 @@ actor BlockDownloaderImpl {
         service: LightWalletService,
         downloaderService: BlockDownloaderService,
         storage: CompactBlockRepository,
+        internalSyncProgress: InternalSyncProgress,
         metrics: SDKMetrics,
         logger: Logger
     ) {
         self.service = service
         self.downloaderService = downloaderService
         self.storage = storage
+        self.internalSyncProgress = internalSyncProgress
         self.metrics = metrics
         self.logger = logger
     }
@@ -106,6 +100,8 @@ actor BlockDownloaderImpl {
                 throw ZcashError.blockDownloadSyncRangeNotSet
             }
 
+            let latestDownloadedBlockHeight = await internalSyncProgress.load(.latestDownloadedBlockHeight)
+
             let downloadFrom = max(syncRange.lowerBound, latestDownloadedBlockHeight + 1)
             let downloadTo = min(downloadToHeight, syncRange.upperBound)
 
@@ -199,8 +195,13 @@ actor BlockDownloaderImpl {
         var counter = 0
         var lastDownloadedBlockHeight = -1
 
-        let pushMetrics: (BlockHeight, Date, Date) -> Void = { [metrics] _, startTime, finishTime in
+        let pushMetrics: (BlockHeight, Date, Date) -> Void = { [metrics] lastDownloadedBlockHeight, startTime, finishTime in
             metrics.pushProgressReport(
+                progress: BlockProgress(
+                    startHeight: totalProgressRange.lowerBound,
+                    targetHeight: totalProgressRange.upperBound,
+                    progressHeight: Int(lastDownloadedBlockHeight)
+                ),
                 start: startTime,
                 end: finishTime,
                 batchSize: maxBlockBufferSize,
@@ -219,7 +220,7 @@ actor BlockDownloaderImpl {
             if buffer.count >= maxBlockBufferSize {
                 let finishTime = Date()
                 try await storage.write(blocks: buffer)
-                try await blocksBufferWritten(buffer)
+                await blocksBufferWritten(buffer)
                 buffer.removeAll(keepingCapacity: true)
 
                 pushMetrics(block.height, startTime, finishTime)
@@ -234,36 +235,21 @@ actor BlockDownloaderImpl {
         }
 
         try await storage.write(blocks: buffer)
-        try await blocksBufferWritten(buffer)
+        await blocksBufferWritten(buffer)
     }
 
-    private func blocksBufferWritten(_ buffer: [ZcashCompactBlock]) async throws {
+    private func blocksBufferWritten(_ buffer: [ZcashCompactBlock]) async {
         guard let lastBlock = buffer.last else { return }
-        latestDownloadedBlockHeight = lastBlock.height
+        await internalSyncProgress.set(lastBlock.height, .latestDownloadedBlockHeight)
     }
 }
 
 extension BlockDownloaderImpl: BlockDownloader {
-    func rewind(latestDownloadedBlockHeight: BlockHeight?) async {
-        self.latestDownloadedBlockHeight = latestDownloadedBlockHeight ?? -1
-    }
-    
-    func update(latestDownloadedBlockHeight: BlockHeight, force: Bool = false) async {
-        if latestDownloadedBlockHeight >= self.latestDownloadedBlockHeight || force {
-            self.latestDownloadedBlockHeight = latestDownloadedBlockHeight
-        }
-    }
-
-    func latestDownloadedBlockHeight() async -> BlockHeight {
-        latestDownloadedBlockHeight
-    }
-
     func setDownloadLimit(_ limit: BlockHeight) async {
         downloadToHeight = limit
     }
 
     func setSyncRange(_ range: CompactBlockRange, batchSize: Int) async throws {
-        guard range != syncRange else { return }
         downloadStream = nil
         self.batchSize = batchSize
         syncRange = range
@@ -296,13 +282,13 @@ extension BlockDownloaderImpl: BlockDownloader {
 
     func waitUntilRequestedBlocksAreDownloaded(in range: CompactBlockRange) async throws {
         logger.debug("Waiting until requested blocks are downloaded at \(range)")
-        var latestDownloadedBlock = latestDownloadedBlockHeight
+        var latestDownloadedBlock = await internalSyncProgress.load(.latestDownloadedBlockHeight)
         while latestDownloadedBlock < range.upperBound {
             if let error = lastError {
                 throw error
             }
             try await Task.sleep(milliseconds: 10)
-            latestDownloadedBlock = latestDownloadedBlockHeight
+            latestDownloadedBlock = await internalSyncProgress.load(.latestDownloadedBlockHeight)
         }
         logger.debug("Waiting done. Blocks are downloaded at \(range)")
     }

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

@@ -107,8 +107,8 @@ extension BlockDownloaderServiceImpl: BlockDownloaderService {
         try await self.storage.rewind(to: height)
     }
 
-    func lastDownloadedBlockHeight() async throws -> BlockHeight {
-        try await self.storage.latestHeight()
+    func lastDownloadedBlockHeight() async -> BlockHeight {
+        await self.storage.latestHeight()
     }
     
     func fetchTransaction(txId: Data) async throws -> ZcashTransaction.Fetched {

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

@@ -7,56 +7,13 @@
 
 import Foundation
 
-public struct EnhancementProgress: Equatable {
-    /// total transactions that were detected in the `range`
-    public let totalTransactions: Int
-    /// enhanced transactions so far
-    public let enhancedTransactions: Int
-    /// last found transaction
-    public let lastFoundTransaction: ZcashTransaction.Overview?
-    /// block range that's being enhanced
-    public let range: CompactBlockRange
-    /// whether this transaction can be considered `newly mined` and not part of the
-    /// wallet catching up to stale and uneventful blocks.
-    public let newlyMined: Bool
-
-    public init(
-        totalTransactions: Int,
-        enhancedTransactions: Int,
-        lastFoundTransaction: ZcashTransaction.Overview?,
-        range: CompactBlockRange,
-        newlyMined: Bool
-    ) {
-        self.totalTransactions = totalTransactions
-        self.enhancedTransactions = enhancedTransactions
-        self.lastFoundTransaction = lastFoundTransaction
-        self.range = range
-        self.newlyMined = newlyMined
-    }
-
-    public var progress: Float {
-        totalTransactions > 0 ? Float(enhancedTransactions) / Float(totalTransactions) : 0
-    }
-
-    public static var zero: EnhancementProgress {
-        EnhancementProgress(totalTransactions: 0, enhancedTransactions: 0, lastFoundTransaction: nil, range: 0...0, newlyMined: false)
-    }
-
-    public static func == (lhs: EnhancementProgress, rhs: EnhancementProgress) -> Bool {
-        return
-            lhs.totalTransactions == rhs.totalTransactions &&
-            lhs.enhancedTransactions == rhs.enhancedTransactions &&
-            lhs.lastFoundTransaction?.rawID == rhs.lastFoundTransaction?.rawID &&
-            lhs.range == rhs.range
-    }
-}
-
 protocol BlockEnhancer {
-    func enhance(at range: CompactBlockRange, didEnhance: @escaping (EnhancementProgress) async -> Void) async throws -> [ZcashTransaction.Overview]?
+    func enhance(at range: CompactBlockRange, didEnhance: (EnhancementProgress) async -> Void) async throws -> [ZcashTransaction.Overview]?
 }
 
 struct BlockEnhancerImpl {
     let blockDownloaderService: BlockDownloaderService
+    let internalSyncProgress: InternalSyncProgress
     let rustBackend: ZcashRustBackendWelding
     let transactionRepository: TransactionRepository
     let metrics: SDKMetrics
@@ -81,7 +38,7 @@ struct BlockEnhancerImpl {
 }
 
 extension BlockEnhancerImpl: BlockEnhancer {
-    func enhance(at range: CompactBlockRange, didEnhance: @escaping (EnhancementProgress) async -> Void) async throws -> [ZcashTransaction.Overview]? {
+    func enhance(at range: CompactBlockRange, didEnhance: (EnhancementProgress) async -> Void) async throws -> [ZcashTransaction.Overview]? {
         try Task.checkCancellation()
         
         logger.debug("Started Enhancing range: \(range)")
@@ -95,6 +52,7 @@ extension BlockEnhancerImpl: BlockEnhancer {
             let transactions = try await transactionRepository.find(in: range, limit: Int.max, kind: .all)
 
             guard !transactions.isEmpty else {
+                await internalSyncProgress.set(range.upperBound, .latestEnhancedHeight)
                 logger.debug("no transactions detected on range: \(range.lowerBound)...\(range.upperBound)")
                 return nil
             }
@@ -124,6 +82,10 @@ extension BlockEnhancerImpl: BlockEnhancer {
                         )
 
                         await didEnhance(progress)
+
+                        if let minedHeight = confirmedTx.minedHeight {
+                            await internalSyncProgress.set(minedHeight, .latestEnhancedHeight)
+                        }
                     } catch {
                         retries += 1
                         logger.error("could not enhance txId \(transaction.rawID.toHexStringTxId()) - Error: \(error)")
@@ -135,6 +97,11 @@ extension BlockEnhancerImpl: BlockEnhancer {
             }
             
             metrics.pushProgressReport(
+                progress: BlockProgress(
+                    startHeight: range.lowerBound,
+                    targetHeight: range.upperBound,
+                    progressHeight: range.upperBound
+                ),
                 start: startTime,
                 end: Date(),
                 batchSize: range.count,
@@ -144,6 +111,8 @@ extension BlockEnhancerImpl: BlockEnhancer {
             logger.error("error enhancing transactions! \(error)")
             throw error
         }
+
+        await internalSyncProgress.set(range.upperBound, .latestEnhancedHeight)
         
         if Task.isCancelled {
             logger.debug("Warning: compactBlockEnhancement on range \(range) cancelled")

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

@@ -18,7 +18,8 @@ struct UTXOFetcherConfig {
 
 protocol UTXOFetcher {
     func fetch(
-        didFetch: @escaping (Float) async -> Void
+        at range: CompactBlockRange,
+        didFetch: (Float) async -> Void
     ) async throws -> (inserted: [UnspentTransactionOutputEntity], skipped: [UnspentTransactionOutputEntity])
 }
 
@@ -26,6 +27,7 @@ struct UTXOFetcherImpl {
     let accountRepository: AccountRepository
     let blockDownloaderService: BlockDownloaderService
     let config: UTXOFetcherConfig
+    let internalSyncProgress: InternalSyncProgress
     let rustBackend: ZcashRustBackendWelding
     let metrics: SDKMetrics
     let logger: Logger
@@ -33,7 +35,8 @@ struct UTXOFetcherImpl {
 
 extension UTXOFetcherImpl: UTXOFetcher {
     func fetch(
-        didFetch: @escaping (Float) async -> Void
+        at range: CompactBlockRange,
+        didFetch: (Float) async -> Void
     ) async throws -> (inserted: [UnspentTransactionOutputEntity], skipped: [UnspentTransactionOutputEntity]) {
         try Task.checkCancellation()
 
@@ -79,6 +82,7 @@ extension UTXOFetcherImpl: UTXOFetcher {
 
                 counter += 1
                 await didFetch(counter / all)
+                await internalSyncProgress.set(utxo.height, .latestUTXOFetchedHeight)
             } catch {
                 logger.error("failed to put utxo - error: \(error)")
                 skipped.append(utxo)
@@ -86,16 +90,23 @@ extension UTXOFetcherImpl: UTXOFetcher {
         }
 
         metrics.pushProgressReport(
+            progress: BlockProgress(
+                startHeight: range.lowerBound,
+                targetHeight: range.upperBound,
+                progressHeight: range.upperBound
+            ),
             start: startTime,
             end: Date(),
-            batchSize: 1,
+            batchSize: range.count,
             operation: .fetchUTXOs
         )
 
         let result = (inserted: refreshed, skipped: skipped)
 
+        await internalSyncProgress.set(range.upperBound, .latestUTXOFetchedHeight)
+
         if Task.isCancelled {
-            logger.debug("Warning: fetchUnspentTxOutputs cancelled")
+            logger.debug("Warning: fetchUnspentTxOutputs on range \(range) cancelled")
         }
 
         return result

package/ios/ZCashLightClientKit/Block/FilesystemStorage/FSCompactBlockRepository.swift

@@ -64,8 +64,8 @@ extension FSCompactBlockRepository: CompactBlockRepository {
         }
     }
 
-    func latestHeight() async throws -> BlockHeight {
-        try await metadataStore.latestHeight()
+    func latestHeight() async -> BlockHeight {
+        await metadataStore.latestHeight()
     }
 
     func write(blocks: [ZcashCompactBlock]) async throws {
@@ -251,7 +251,7 @@ struct FSMetadataStore {
     let saveBlocksMeta: ([ZcashCompactBlock]) async throws -> Void
     let rewindToHeight: (BlockHeight) async throws -> Void
     let initFsBlockDbRoot: () async throws -> Void
-    let latestHeight: () async throws -> BlockHeight
+    let latestHeight: () async -> BlockHeight
 }
 
 extension FSMetadataStore {
@@ -268,7 +268,7 @@ extension FSMetadataStore {
         } initFsBlockDbRoot: {
             try await rustBackend.initBlockMetadataDb()
         } latestHeight: {
-            try await rustBackend.latestCachedBlockHeight()
+            await rustBackend.latestCachedBlockHeight()
         }
     }
 }

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

@@ -16,7 +16,8 @@ protocol BlockScanner {
     @discardableResult
     func scanBlocks(
         at range: CompactBlockRange,
-        didScan: @escaping (BlockHeight, UInt32) async throws -> Void
+        totalProgressRange: CompactBlockRange,
+        didScan: @escaping (BlockHeight) async -> Void
     ) async throws -> BlockHeight
 }
 
@@ -26,18 +27,20 @@ struct BlockScannerImpl {
     let transactionRepository: TransactionRepository
     let metrics: SDKMetrics
     let logger: Logger
+    let latestBlocksDataProvider: LatestBlocksDataProvider
 }
 
 extension BlockScannerImpl: BlockScanner {
     @discardableResult
     func scanBlocks(
         at range: CompactBlockRange,
-        didScan: @escaping (BlockHeight, UInt32) async throws -> Void
+        totalProgressRange: CompactBlockRange,
+        didScan: @escaping (BlockHeight) async -> Void
     ) async throws -> BlockHeight {
         logger.debug("Going to scan blocks in range: \(range)")
         try Task.checkCancellation()
 
-        let scanStartHeight = range.lowerBound
+        let scanStartHeight = try await transactionRepository.lastScannedHeight()
         let targetScanHeight = range.upperBound
 
         var scannedNewBlocks = false
@@ -47,13 +50,13 @@ extension BlockScannerImpl: BlockScanner {
             try Task.checkCancellation()
 
             let previousScannedHeight = lastScannedHeight
-            let startHeight = previousScannedHeight + 1
 
-            let batchSize = UInt32(config.scanningBatchSize)
+            // TODO: [#576] remove this arbitrary batch size https://github.com/zcash/ZcashLightClientKit/issues/576
+            let batchSize = scanBatchSize(startScanHeight: previousScannedHeight + 1, network: config.networkType)
 
             let scanStartTime = Date()
             do {
-                try await self.rustBackend.scanBlocks(fromHeight: Int32(startHeight), limit: batchSize)
+                try await self.rustBackend.scanBlocks(limit: batchSize)
             } catch {
                 logger.debug("block scanning failed with error: \(String(describing: error))")
                 throw error
@@ -61,15 +64,24 @@ extension BlockScannerImpl: BlockScanner {
 
             let scanFinishTime = Date()
 
-            // TODO: [#1259] potential bug when rustBackend.scanBlocks scan less blocks than batchSize,
-            // https://github.com/zcash/ZcashLightClientKit/issues/1259
-            lastScannedHeight = startHeight + Int(batchSize) - 1
+            if let lastScannedBlock = try await transactionRepository.lastScannedBlock() {
+                lastScannedHeight = lastScannedBlock.height
+                await latestBlocksDataProvider.updateLatestScannedHeight(lastScannedHeight)
+                await latestBlocksDataProvider.updateLatestScannedTime(TimeInterval(lastScannedBlock.time))
+            }
             
             scannedNewBlocks = previousScannedHeight != lastScannedHeight
             if scannedNewBlocks {
-                try await didScan(lastScannedHeight, batchSize)
+                await didScan(lastScannedHeight)
+
+                let progress = BlockProgress(
+                    startHeight: totalProgressRange.lowerBound,
+                    targetHeight: totalProgressRange.upperBound,
+                    progressHeight: lastScannedHeight
+                )
 
                 metrics.pushProgressReport(
+                    progress: progress,
                     start: scanStartTime,
                     end: scanFinishTime,
                     batchSize: Int(batchSize),
@@ -86,4 +98,17 @@ extension BlockScannerImpl: BlockScanner {
 
         return lastScannedHeight
     }
+
+    private func scanBatchSize(startScanHeight height: BlockHeight, network: NetworkType) -> UInt32 {
+        assert(config.scanningBatchSize > 0, "ZcashSDK.DefaultScanningBatch must be larger than 0!")
+        guard network == .mainnet else { return UInt32(config.scanningBatchSize) }
+
+        if height > 1_650_000 {
+            // librustzcash thread saturation at a number of blocks
+            // that contains 100 * num_cores Sapling outputs.
+            return UInt32(max(ProcessInfo().activeProcessorCount, 10))
+        }
+
+        return UInt32(config.scanningBatchSize)
+    }
 }

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

@@ -0,0 +1,200 @@
+//
+//  InternalSyncProgress.swift
+//  
+//
+//  Created by Michal Fousek on 23.11.2022.
+//
+
+import Foundation
+
+struct SyncRanges: Equatable {
+    let latestBlockHeight: BlockHeight
+    /// The sync process can be interrupted in any phase. It may happen that it's interrupted while downloading blocks. In that case in next sync
+    /// process already downloaded blocks needs to be scanned before the sync process starts to download new blocks. And the range of blocks that are
+    /// already downloaded but not scanned is stored in this variable.
+    let downloadedButUnscannedRange: CompactBlockRange?
+    /// Range of blocks that are not yet downloaded and not yet scanned.
+    let downloadAndScanRange: CompactBlockRange?
+    /// Range of blocks that are not enhanced yet.
+    let enhanceRange: CompactBlockRange?
+    /// Range of blocks for which no UTXOs are fetched yet.
+    let fetchUTXORange: CompactBlockRange?
+
+    let latestScannedHeight: BlockHeight?
+
+    let latestDownloadedBlockHeight: BlockHeight?
+}
+
+protocol InternalSyncProgressStorage {
+    func bool(forKey defaultName: String) -> Bool
+    func integer(forKey defaultName: String) -> Int
+    func set(_ value: Int, forKey defaultName: String)
+    func set(_ value: Bool, forKey defaultName: String)
+    @discardableResult
+    func synchronize() -> Bool
+}
+
+extension UserDefaults: InternalSyncProgressStorage { }
+
+actor InternalSyncProgress {
+    enum Key: String, CaseIterable {
+        case latestDownloadedBlockHeight
+        case latestEnhancedHeight
+        case latestUTXOFetchedHeight
+
+        func with(_ alias: ZcashSynchronizerAlias) -> String {
+            switch alias {
+            case .`default`:
+                return self.rawValue
+            case let .custom(rawAlias):
+                return "\(self.rawValue)_\(rawAlias)"
+            }
+        }
+    }
+
+    private let alias: ZcashSynchronizerAlias
+    private let storage: InternalSyncProgressStorage
+    let logger: Logger
+
+    var latestDownloadedBlockHeight: BlockHeight { load(.latestDownloadedBlockHeight) }
+    var latestEnhancedHeight: BlockHeight { load(.latestEnhancedHeight) }
+    var latestUTXOFetchedHeight: BlockHeight { load(.latestUTXOFetchedHeight) }
+
+    init(alias: ZcashSynchronizerAlias, storage: InternalSyncProgressStorage, logger: Logger) {
+        self.alias = alias
+        self.storage = storage
+        self.logger = logger
+    }
+
+    func load(_ key: Key) -> BlockHeight {
+        storage.integer(forKey: key.with(alias))
+    }
+
+    func set(_ value: BlockHeight, _ key: Key) {
+        storage.set(value, forKey: key.with(alias))
+        storage.synchronize()
+    }
+
+    func rewind(to: BlockHeight) {
+        Key.allCases.forEach { key in
+            let finalRewindHeight = min(load(key), to)
+            self.set(finalRewindHeight, key)
+        }
+    }
+
+    /// `InternalSyncProgress` is from now on used to track which block were already downloaded. Previous versions of the SDK were using cache DB to
+    /// track this. Because of this we have to migrate height of latest downloaded block from cache DB to here.
+    ///
+    /// - Parameter latestDownloadedBlockHeight: Height of latest downloaded block from cache DB.
+    func migrateIfNeeded(latestDownloadedBlockHeightFromCacheDB latestDownloadedBlockHeight: BlockHeight) {
+        let key = "InternalSyncProgressMigrated"
+        if !storage.bool(forKey: key) {
+            set(latestDownloadedBlockHeight, .latestDownloadedBlockHeight)
+        }
+        storage.set(true, forKey: key)
+        storage.synchronize()
+    }
+
+    /// Computes the next state for the sync process. Thanks to this it's possible to interrupt the sync process at any phase and then it can be safely
+    /// resumed.
+    ///
+    /// The sync process has 4 phases (download, scan, enhance, fetch UTXO). `InternalSyncProgress` tracks independently which blocks were already
+    /// processed in each phase. To compute the next state these 4 numbers are compared with `latestBlockHeight`.
+    ///
+    /// - If any of these numbers are larger than `latestBlockHeight` then `wait` is used as the next state. We have locally higher block heights than
+    ///   are currently available at LightWalletd.
+    /// - If any of these numbers are lower than `latestBlockHeight` then `processNewBlocks` is used as the next state. The sync process should run.
+    /// - Otherwise `finishProcessing` is used as the next state. It means that local data are synced with what is available at LightWalletd.
+    ///
+    /// - Parameters:
+    ///   - latestBlockHeight: Latest height fetched from LightWalletd API.
+    ///   - latestScannedHeight: Latest height of latest block scanned.
+    ///   - walletBirthday: Wallet birthday.
+    /// - Returns: Computed state.
+    func computeNextState(
+        latestBlockHeight: BlockHeight,
+        latestScannedHeight: BlockHeight,
+        walletBirthday: BlockHeight
+    ) -> CompactBlockProcessor.NextState {
+        logger.debug("""
+            Init numbers:
+            latestBlockHeight:       \(latestBlockHeight)
+            latestDownloadedHeight:  \(latestDownloadedBlockHeight)
+            latestScannedHeight:     \(latestScannedHeight)
+            latestEnhancedHeight:    \(latestEnhancedHeight)
+            latestUTXOFetchedHeight: \(latestUTXOFetchedHeight)
+            """)
+
+        if  latestDownloadedBlockHeight > latestBlockHeight ||
+            latestScannedHeight > latestBlockHeight ||
+            latestEnhancedHeight > latestBlockHeight ||
+            latestUTXOFetchedHeight > latestBlockHeight {
+            return .wait(latestHeight: latestBlockHeight, latestDownloadHeight: latestDownloadedBlockHeight)
+        } else if latestDownloadedBlockHeight < latestBlockHeight ||
+            latestScannedHeight < latestBlockHeight ||
+            latestEnhancedHeight < latestEnhancedHeight ||
+            latestUTXOFetchedHeight < latestBlockHeight {
+            let ranges = computeSyncRanges(
+                birthday: walletBirthday,
+                latestBlockHeight: latestBlockHeight,
+                latestScannedHeight: latestScannedHeight
+            )
+            return .processNewBlocks(ranges: ranges)
+        } else {
+            return .finishProcessing(height: latestBlockHeight)
+        }
+    }
+
+    func computeSyncRanges(
+        birthday: BlockHeight,
+        latestBlockHeight: BlockHeight,
+        latestScannedHeight: BlockHeight
+    ) -> SyncRanges {
+        // If there is more downloaded then scanned blocks we have to range for these blocks. The sync process will then start with scanning these
+        // blocks instead of downloading new ones.
+        let downloadedButUnscannedRange: CompactBlockRange?
+        if latestScannedHeight < latestDownloadedBlockHeight {
+            downloadedButUnscannedRange = latestScannedHeight + 1...latestDownloadedBlockHeight
+        } else {
+            downloadedButUnscannedRange = nil
+        }
+
+        if latestScannedHeight > latestDownloadedBlockHeight {
+            logger.warn("""
+            InternalSyncProgress found inconsistent state.
+                latestBlockHeight:       \(latestBlockHeight)
+            --> latestDownloadedHeight:  \(latestDownloadedBlockHeight)
+                latestScannedHeight:     \(latestScannedHeight)
+                latestEnhancedHeight:    \(latestEnhancedHeight)
+                latestUTXOFetchedHeight: \(latestUTXOFetchedHeight)
+
+            latest downloaded height
+            """)
+        }
+
+        // compute the range that must be downloaded and scanned based on
+        // birthday, `latestDownloadedBlockHeight`, `latestScannedHeight` and
+        // latest block height fetched from the chain.
+        let downloadAndScanRange = computeRange(
+            latestHeight: max(latestDownloadedBlockHeight, latestScannedHeight),
+            birthday: birthday,
+            latestBlockHeight: latestBlockHeight
+        )
+
+        return SyncRanges(
+            latestBlockHeight: latestBlockHeight,
+            downloadedButUnscannedRange: downloadedButUnscannedRange,
+            downloadAndScanRange: downloadAndScanRange,
+            enhanceRange: computeRange(latestHeight: latestEnhancedHeight, birthday: birthday, latestBlockHeight: latestBlockHeight),
+            fetchUTXORange: computeRange(latestHeight: latestUTXOFetchedHeight, birthday: birthday, latestBlockHeight: latestBlockHeight),
+            latestScannedHeight: latestScannedHeight,
+            latestDownloadedBlockHeight: latestDownloadedBlockHeight
+        )
+    }
+
+    private func computeRange(latestHeight: BlockHeight, birthday: BlockHeight, latestBlockHeight: BlockHeight) -> CompactBlockRange? {
+        guard latestHeight < latestBlockHeight else { return nil }
+        let lowerBound = latestHeight <= birthday ? birthday : latestHeight + 1
+        return lowerBound...latestBlockHeight
+    }
+}