react-native-zcash 0.6.11 → 0.6.12

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+## 0.6.12 (2024-04-10)
+
+- fixed: Correct packaging mistake the previous release
+
 ## 0.6.11 (2024-04-10)
 
 - changed: Updated checkpoints

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

@@ -0,0 +1,98 @@
+//
+//  Action.swift
+//  
+//
+//  Created by Michal Fousek on 05.05.2023.
+//
+
+import Foundation
+
+protocol ActionContext {
+    var state: CBPState { get async }
+    var prevState: CBPState? { get async }
+    var syncControlData: SyncControlData { get async }
+    var requestedRewindHeight: BlockHeight? { get async }
+    var processedHeight: BlockHeight { get async }
+    var lastChainTipUpdateTime: TimeInterval { get async }
+    var lastScannedHeight: BlockHeight? { get async }
+    var lastEnhancedHeight: BlockHeight? { get async }
+    
+    func update(state: CBPState) async
+    func update(syncControlData: SyncControlData) async
+    func update(processedHeight: BlockHeight) async
+    func update(lastChainTipUpdateTime: TimeInterval) async
+    func update(lastScannedHeight: BlockHeight) async
+    func update(lastDownloadedHeight: BlockHeight) async
+    func update(lastEnhancedHeight: BlockHeight?) async
+    func update(requestedRewindHeight: BlockHeight) async
+}
+
+actor ActionContextImpl: ActionContext {
+    var state: CBPState
+    var prevState: CBPState?
+    var syncControlData: SyncControlData
+    var requestedRewindHeight: BlockHeight?
+    /// Amount of blocks that have been processed so far
+    var processedHeight: BlockHeight = 0
+    /// Update chain tip must be called repeatadly, this value stores the previous update and help to decide when to call it again
+    var lastChainTipUpdateTime: TimeInterval = 0.0
+    var lastScannedHeight: BlockHeight?
+    var lastDownloadedHeight: BlockHeight?
+    var lastEnhancedHeight: BlockHeight?
+
+    init(state: CBPState) {
+        self.state = state
+        syncControlData = SyncControlData.empty
+    }
+
+    func update(state: CBPState) async {
+        prevState = self.state
+        self.state = state
+    }
+    func update(syncControlData: SyncControlData) async { self.syncControlData = syncControlData }
+    func update(processedHeight: BlockHeight) async { self.processedHeight = processedHeight }
+    func update(lastChainTipUpdateTime: TimeInterval) async { self.lastChainTipUpdateTime = lastChainTipUpdateTime }
+    func update(lastScannedHeight: BlockHeight) async { self.lastScannedHeight = lastScannedHeight }
+    func update(lastDownloadedHeight: BlockHeight) async { self.lastDownloadedHeight = lastDownloadedHeight }
+    func update(lastEnhancedHeight: BlockHeight?) async { self.lastEnhancedHeight = lastEnhancedHeight }
+    func update(requestedRewindHeight: BlockHeight) async { self.requestedRewindHeight = requestedRewindHeight }
+}
+
+enum CBPState: CaseIterable {
+    case idle
+    case migrateLegacyCacheDB
+    case validateServer
+    case updateSubtreeRoots
+    case updateChainTip
+    case processSuggestedScanRanges
+    case rewind
+    case download
+    case scan
+    case clearAlreadyScannedBlocks
+    case enhance
+    case fetchUTXO
+    case handleSaplingParams
+    case clearCache
+    case finished
+    case failed
+    case stopped
+}
+
+protocol Action {
+    /// If this is true and action fails with error then blocks cache is cleared.
+    var removeBlocksCacheWhenFailed: Bool { get }
+
+    // When any action is created it can get `DIContainer` and resolve any depedencies it requires.
+    // Every action uses `context` to get some informartion like download range.
+    //
+    // `didUpdate` is closure that action use to tell CBP that some part of the work is done. For example if download action would like to
+    // update progress on every block downloaded it can use this closure. Also if action doesn't need to update progress on partial work it doesn't
+    // need to use this closure at all.
+    //
+    // Each action updates context accordingly. It should at least set new state. Reason for this is that action can return different states for
+    // different conditions. And action is the thing that knows these conditions.
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext
+
+    // Should be called on each existing action when processor wants to stop. Some actions may do it's own background work.
+    func stop() async
+}

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

@@ -0,0 +1,35 @@
+//
+//  ClearCacheForLastScannedBatch.swift
+//  
+//
+//  Created by Michal Fousek on 08.05.2023.
+//
+
+import Foundation
+
+final class ClearAlreadyScannedBlocksAction {
+    let storage: CompactBlockRepository
+    let transactionRepository: TransactionRepository
+    
+    init(container: DIContainer) {
+        storage = container.resolve(CompactBlockRepository.self)
+        transactionRepository = container.resolve(TransactionRepository.self)
+    }
+}
+
+extension ClearAlreadyScannedBlocksAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        guard let lastScannedHeight = await context.lastScannedHeight else {
+            throw ZcashError.compactBlockProcessorLastScannedHeight
+        }
+        
+        try await storage.clear(upTo: lastScannedHeight)
+
+        await context.update(state: .enhance)
+        return context
+    }
+
+    func stop() async { }
+}

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

@@ -0,0 +1,30 @@
+//
+//  ClearCacheAction.swift
+//  
+//
+//  Created by Michal Fousek on 05.05.2023.
+//
+
+import Foundation
+
+final class ClearCacheAction {
+    let storage: CompactBlockRepository
+
+    init(container: DIContainer) {
+        storage = container.resolve(CompactBlockRepository.self)
+    }
+}
+
+extension ClearCacheAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        try await storage.clear()
+        
+        await context.update(state: .processSuggestedScanRanges)
+        
+        return context
+    }
+
+    func stop() async { }
+}

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

@@ -0,0 +1,67 @@
+//
+//  DownloadAction.swift
+//  
+//
+//  Created by Michal Fousek on 05.05.2023.
+//
+
+import Foundation
+
+final class DownloadAction {
+    let configProvider: CompactBlockProcessor.ConfigProvider
+    let downloader: BlockDownloader
+    let transactionRepository: TransactionRepository
+    let logger: Logger
+
+    init(container: DIContainer, configProvider: CompactBlockProcessor.ConfigProvider) {
+        self.configProvider = configProvider
+        downloader = container.resolve(BlockDownloader.self)
+        transactionRepository = container.resolve(TransactionRepository.self)
+        logger = container.resolve(Logger.self)
+    }
+
+    private func update(context: ActionContext) async -> ActionContext {
+        await context.update(state: .scan)
+        return context
+    }
+}
+
+extension DownloadAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { true }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        guard let lastScannedHeight = await context.lastScannedHeight else {
+            return await update(context: context)
+        }
+
+        let config = await configProvider.config
+        let latestBlockHeight = await context.syncControlData.latestBlockHeight
+        // This action is executed for each batch (batch size is 100 blocks by default) until all the blocks in whole `downloadRange` are downloaded.
+        // So the right range for this batch must be computed.
+        let batchRangeStart = lastScannedHeight
+        let batchRangeEnd = min(latestBlockHeight, batchRangeStart + config.batchSize)
+
+        guard batchRangeStart <= batchRangeEnd else {
+            return await update(context: context)
+        }
+
+        let batchRange = batchRangeStart...batchRangeEnd
+        let potentialDownloadLimit = batchRange.upperBound + (2 * config.batchSize)
+        let downloadLimit = await context.syncControlData.latestBlockHeight >= potentialDownloadLimit ? potentialDownloadLimit : batchRangeEnd
+
+        logger.debug("Starting download with range: \(batchRangeStart)...\(batchRangeEnd)")
+        
+        await downloader.update(latestDownloadedBlockHeight: batchRangeStart, force: true)
+        try await downloader.setSyncRange(lastScannedHeight...latestBlockHeight, batchSize: config.batchSize)
+        await downloader.setDownloadLimit(downloadLimit)
+        await downloader.startDownload(maxBlockBufferSize: config.downloadBufferSize)
+
+        try await downloader.waitUntilRequestedBlocksAreDownloaded(in: batchRange)
+
+        return await update(context: context)
+    }
+
+    func stop() async {
+        await downloader.stopDownload()
+    }
+}

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

@@ -0,0 +1,97 @@
+//
+//  EnhanceAction.swift
+//  
+//
+//  Created by Michal Fousek on 05.05.2023.
+//
+
+import Foundation
+
+final class EnhanceAction {
+    let blockEnhancer: BlockEnhancer
+    let configProvider: CompactBlockProcessor.ConfigProvider
+    let logger: Logger
+    
+    init(container: DIContainer, configProvider: CompactBlockProcessor.ConfigProvider) {
+        blockEnhancer = container.resolve(BlockEnhancer.self)
+        self.configProvider = configProvider
+        logger = container.resolve(Logger.self)
+    }
+
+    func decideWhatToDoNext(context: ActionContext, lastScannedHeight: BlockHeight) async -> ActionContext {
+        guard await context.syncControlData.latestScannedHeight != nil else {
+            await context.update(state: .clearCache)
+            return context
+        }
+
+        let latestBlockHeight = await context.syncControlData.latestBlockHeight
+        if lastScannedHeight >= latestBlockHeight {
+            await context.update(state: .clearCache)
+        } else {
+            await context.update(state: .updateChainTip)
+        }
+
+        return context
+    }
+}
+
+extension EnhanceAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        // Use `BlockEnhancer` to enhance blocks.
+        // This action is executed on each downloaded and scanned batch (typically each 100 blocks). But we want to run enhancement each 1000 blocks.
+
+        // if latestScannedHeight >= context.scanRanges.scanRange.upperBound then everything is processed and sync process should continue to end.
+        // If latestScannedHeight < context.scanRanges.scanRange.upperBound then set state to `download` because there are blocks to
+        // download and scan.
+
+        let config = await configProvider.config
+        guard let lastScannedHeight = await context.lastScannedHeight else {
+            throw ZcashError.compactBlockProcessorLastScannedHeight
+        }
+
+        guard let firstUnenhancedHeight = await context.syncControlData.firstUnenhancedHeight else {
+            return await decideWhatToDoNext(context: context, lastScannedHeight: lastScannedHeight)
+        }
+
+        let latestBlockHeight = await context.syncControlData.latestBlockHeight
+        let lastEnhancedHeight: BlockHeight
+        if let lastEnhancedHeightInContext = await context.lastEnhancedHeight {
+            lastEnhancedHeight = lastEnhancedHeightInContext
+        } else {
+            lastEnhancedHeight = -1
+        }
+        let enhanceRangeStart = max(firstUnenhancedHeight, lastEnhancedHeight + 1)
+        let enhanceRangeEnd = min(latestBlockHeight, lastScannedHeight)
+        
+        // This may happen:
+        // For example whole enhance range is 0...2100 Without this force enhance is done for ranges: 0...1000, 1001...2000. And that's it.
+        // Last 100 blocks isn't enhanced.
+        //
+        // This force makes sure that all the blocks are enhanced even when last enhance happened < 1000 blocks ago.
+        let forceEnhance = enhanceRangeEnd == latestBlockHeight && enhanceRangeEnd - enhanceRangeStart <= config.enhanceBatchSize
+
+        if enhanceRangeStart <= enhanceRangeEnd && (forceEnhance || (lastScannedHeight - lastEnhancedHeight >= config.enhanceBatchSize)) {
+            let enhanceRange = enhanceRangeStart...enhanceRangeEnd
+            let transactions = try await blockEnhancer.enhance(
+                at: enhanceRange,
+                didEnhance: { progress in
+                    if let foundTx = progress.lastFoundTransaction, progress.newlyMined {
+                        await didUpdate(.minedTransaction(foundTx))
+                    }
+                }
+            )
+
+            await context.update(lastEnhancedHeight: enhanceRange.upperBound)
+
+            if let transactions {
+                await didUpdate(.foundTransactions(transactions, enhanceRange))
+            }
+        }
+
+        return await decideWhatToDoNext(context: context, lastScannedHeight: lastScannedHeight)
+    }
+
+    func stop() async { }
+}

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

@@ -0,0 +1,33 @@
+//
+//  FetchUTXOsAction.swift
+//  
+//
+//  Created by Michal Fousek on 05.05.2023.
+//
+
+import Foundation
+
+final class FetchUTXOsAction {
+    let utxoFetcher: UTXOFetcher
+    let logger: Logger
+
+    init(container: DIContainer) {
+        utxoFetcher = container.resolve(UTXOFetcher.self)
+        logger = container.resolve(Logger.self)
+    }
+}
+
+extension FetchUTXOsAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        logger.debug("Fetching UTXOs")
+        let result = try await utxoFetcher.fetch() { _ in }
+        await didUpdate(.storedUTXOs(result))
+
+        await context.update(state: .handleSaplingParams)
+        return context
+    }
+
+    func stop() async { }
+}

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

@@ -0,0 +1,70 @@
+//
+//  MigrateLegacyCacheDB.swift
+//  
+//
+//  Created by Michal Fousek on 10.05.2023.
+//
+
+import Foundation
+
+final class MigrateLegacyCacheDBAction {
+    private let configProvider: CompactBlockProcessor.ConfigProvider
+    private let storage: CompactBlockRepository
+    private let transactionRepository: TransactionRepository
+    private let fileManager: ZcashFileManager
+
+    init(container: DIContainer, configProvider: CompactBlockProcessor.ConfigProvider) {
+        self.configProvider = configProvider
+        storage = container.resolve(CompactBlockRepository.self)
+        transactionRepository = container.resolve(TransactionRepository.self)
+        fileManager = container.resolve(ZcashFileManager.self)
+    }
+
+    private func updateState(_ context: ActionContext) async -> ActionContext {
+        await context.update(state: .validateServer)
+        return context
+    }
+}
+
+extension MigrateLegacyCacheDBAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        let config = await configProvider.config
+        guard let legacyCacheDbURL = config.cacheDbURL else {
+            return await updateState(context)
+        }
+
+        guard legacyCacheDbURL != config.fsBlockCacheRoot else {
+            throw ZcashError.compactBlockProcessorCacheDbMigrationFsCacheMigrationFailedSameURL
+        }
+
+        // Instance with alias `default` is same as instance before the Alias was introduced. So it makes sense that only this instance handles
+        // legacy cache DB. Any instance with different than `default` alias was created after the Alias was introduced and at this point legacy
+        // cache DB doesn't exist anymore. So there is nothing to migrate for instances with not default Alias.
+        guard config.alias == .default else {
+            return await updateState(context)
+        }
+
+        // if the URL provided is not readable, it means that the client has a reference
+        // to the cacheDb file but it has been deleted in a prior sync cycle. there's
+        // nothing to do here.
+        guard fileManager.isReadableFile(atPath: legacyCacheDbURL.path) else {
+            return await updateState(context)
+        }
+
+        do {
+            // if there's a readable file at the provided URL, delete it.
+            try fileManager.removeItem(at: legacyCacheDbURL)
+        } catch {
+            throw ZcashError.compactBlockProcessorCacheDbMigrationFailedToDeleteLegacyDb(error)
+        }
+
+        // create the storage
+        try await self.storage.create()
+
+        return await updateState(context)
+    }
+
+    func stop() { }
+}

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

@@ -0,0 +1,60 @@
+//
+//  ProcessSuggestedScanRangesAction.swift
+//  
+//
+//  Created by Lukáš Korba on 02.08.2023.
+//
+
+import Foundation
+
+final class ProcessSuggestedScanRangesAction {
+    let rustBackend: ZcashRustBackendWelding
+    let service: LightWalletService
+    let logger: Logger
+    
+    init(container: DIContainer) {
+        service = container.resolve(LightWalletService.self)
+        rustBackend = container.resolve(ZcashRustBackendWelding.self)
+        logger = container.resolve(Logger.self)
+    }
+}
+
+extension ProcessSuggestedScanRangesAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        logger.info("Getting the suggested scan ranges from the wallet database.")
+        let scanRanges = try await rustBackend.suggestScanRanges()
+
+        if let firstRange = scanRanges.first {
+            let rangeStartExclusive = firstRange.range.lowerBound - 1
+            let rangeEndInclusive = firstRange.range.upperBound - 1
+            
+            let syncControlData = SyncControlData(
+                latestBlockHeight: rangeEndInclusive,
+                latestScannedHeight: rangeStartExclusive,
+                firstUnenhancedHeight: rangeStartExclusive + 1
+            )
+            
+            logger.debug("""
+                Init numbers:
+                latestBlockHeight [BC]:         \(rangeEndInclusive)
+                latestScannedHeight [DB]:       \(rangeStartExclusive)
+                firstUnenhancedHeight [DB]:     \(rangeStartExclusive + 1)
+                """)
+
+            await context.update(lastEnhancedHeight: nil)
+            await context.update(lastScannedHeight: rangeStartExclusive)
+            await context.update(lastDownloadedHeight: rangeStartExclusive)
+            await context.update(syncControlData: syncControlData)
+
+            await context.update(state: .download)
+        } else {
+            await context.update(state: .finished)
+        }
+        
+        return context
+    }
+
+    func stop() async { }
+}

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

@@ -0,0 +1,48 @@
+//
+//  RewindAction.swift
+//  
+//
+//  Created by Lukáš Korba on 09.08.2023.
+//
+
+import Foundation
+
+final class RewindAction {
+    let downloader: BlockDownloader
+    let rustBackend: ZcashRustBackendWelding
+    let downloaderService: BlockDownloaderService
+    let logger: Logger
+
+    init(container: DIContainer) {
+        downloader = container.resolve(BlockDownloader.self)
+        rustBackend = container.resolve(ZcashRustBackendWelding.self)
+        downloaderService = container.resolve(BlockDownloaderService.self)
+        logger = container.resolve(Logger.self)
+    }
+    
+    private func update(context: ActionContext) async -> ActionContext {
+        await context.update(state: .processSuggestedScanRanges)
+        return context
+    }
+}
+
+extension RewindAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        guard let rewindHeight = await context.requestedRewindHeight else {
+            return await update(context: context)
+        }
+        
+        logger.debug("Executing rewind.")
+        await downloader.rewind(latestDownloadedBlockHeight: rewindHeight)
+        try await rustBackend.rewindToHeight(height: Int32(rewindHeight))
+        
+        // clear cache
+        try await downloaderService.rewind(to: rewindHeight)
+        
+        return await update(context: context)
+    }
+
+    func stop() async { }
+}

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

@@ -0,0 +1,33 @@
+//
+//  SaplingParamsAction.swift
+//  
+//
+//  Created by Michal Fousek on 05.05.2023.
+//
+
+import Foundation
+
+final class SaplingParamsAction {
+    let saplingParametersHandler: SaplingParametersHandler
+    let logger: Logger
+
+    init(container: DIContainer) {
+        saplingParametersHandler = container.resolve(SaplingParametersHandler.self)
+        logger = container.resolve(Logger.self)
+    }
+}
+
+extension SaplingParamsAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        logger.debug("Fetching sapling parameters")
+        try await saplingParametersHandler.handleIfNeeded()
+        
+        await context.update(state: .updateSubtreeRoots)
+        
+        return context
+    }
+
+    func stop() async { }
+}

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

@@ -0,0 +1,95 @@
+//
+//  ScanAction.swift
+//  
+//
+//  Created by Michal Fousek on 05.05.2023.
+//
+
+import Foundation
+
+final class ScanAction {
+    let configProvider: CompactBlockProcessor.ConfigProvider
+    let blockScanner: BlockScanner
+    let rustBackend: ZcashRustBackendWelding
+    let latestBlocksDataProvider: LatestBlocksDataProvider
+    let logger: Logger
+
+    init(container: DIContainer, configProvider: CompactBlockProcessor.ConfigProvider) {
+        self.configProvider = configProvider
+        blockScanner = container.resolve(BlockScanner.self)
+        rustBackend = container.resolve(ZcashRustBackendWelding.self)
+        latestBlocksDataProvider = container.resolve(LatestBlocksDataProvider.self)
+        logger = container.resolve(Logger.self)
+    }
+
+    private func update(context: ActionContext) async -> ActionContext {
+        await context.update(state: .clearAlreadyScannedBlocks)
+        return context
+    }
+}
+
+extension ScanAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { true }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        guard let lastScannedHeight = await context.lastScannedHeight else {
+            return await update(context: context)
+        }
+
+        let config = await configProvider.config
+        let latestBlockHeight = await context.syncControlData.latestBlockHeight
+        // This action is executed for each batch (batch size is 100 blocks by default) until all the blocks in whole `scanRange` are scanned.
+        // So the right range for this batch must be computed.
+        let batchRangeStart = lastScannedHeight
+        let batchRangeEnd = min(latestBlockHeight, batchRangeStart + config.batchSize)
+
+        guard batchRangeStart <= batchRangeEnd else {
+            return await update(context: context)
+        }
+
+        let batchRange = batchRangeStart...batchRangeEnd
+        
+        logger.debug("Starting scan blocks with range: \(batchRange.lowerBound)...\(batchRange.upperBound)")
+        
+        do {
+            try await blockScanner.scanBlocks(at: batchRange) { [weak self] lastScannedHeight, increment in
+                let processedHeight = await context.processedHeight
+                let incrementedprocessedHeight = processedHeight + BlockHeight(increment)
+                await context.update(processedHeight: incrementedprocessedHeight)
+                await self?.latestBlocksDataProvider.updateScannedData()
+                
+                // report scan progress only if it's available
+                if let scanProgress = try? await self?.rustBackend.getScanProgress() {
+                    let progress = try scanProgress.progress()
+                    self?.logger.debug("progress: \(progress)")
+                    await didUpdate(.syncProgress(progress))
+                }
+                
+                // ScanAction is controlled locally so it must report back the updated scanned height
+                await context.update(lastScannedHeight: lastScannedHeight)
+            }
+        } catch ZcashError.rustScanBlocks(let errorMsg) {
+            if isContinuityError(errorMsg) {
+                await context.update(requestedRewindHeight: batchRange.lowerBound - 10)
+                await context.update(state: .rewind)
+                return context
+            } else {
+                throw ZcashError.rustScanBlocks(errorMsg)
+            }
+        } catch {
+            throw error
+        }
+
+        return await update(context: context)
+    }
+
+    func stop() async { }
+}
+
+private extension ScanAction {
+    func isContinuityError(_ errorMsg: String) -> Bool {
+        errorMsg.contains("The parent hash of proposed block does not correspond to the block hash at height")
+        || errorMsg.contains("Block height discontinuity at height")
+        || errorMsg.contains("note commitment tree size provided by a compact block did not match the expected size at height")
+    }
+}