react-native-zcash 0.6.11 → 0.6.13

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")
+    }
+}

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

@@ -0,0 +1,55 @@
+//
+//  UpdateChainTipAction.swift
+//  
+//
+//  Created by Lukáš Korba on 01.08.2023.
+//
+
+import Foundation
+
+final class UpdateChainTipAction {
+    let rustBackend: ZcashRustBackendWelding
+    let downloader: BlockDownloader
+    let service: LightWalletService
+    let latestBlocksDataProvider: LatestBlocksDataProvider
+    let logger: Logger
+    
+    init(container: DIContainer) {
+        service = container.resolve(LightWalletService.self)
+        downloader = container.resolve(BlockDownloader.self)
+        rustBackend = container.resolve(ZcashRustBackendWelding.self)
+        latestBlocksDataProvider = container.resolve(LatestBlocksDataProvider.self)
+        logger = container.resolve(Logger.self)
+    }
+    
+    func updateChainTip(_ context: ActionContext, time: TimeInterval) async throws {
+        let latestBlockHeight = try await service.latestBlockHeight()
+        
+        logger.info("Latest block height is \(latestBlockHeight)")
+        try await rustBackend.updateChainTip(height: Int32(latestBlockHeight))
+        await context.update(lastChainTipUpdateTime: time)
+        await latestBlocksDataProvider.update(latestBlockHeight)
+    }
+}
+
+extension UpdateChainTipAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        let lastChainTipUpdateTime = await context.lastChainTipUpdateTime
+        let now = Date().timeIntervalSince1970
+
+        // Update chain tip can be called from different contexts
+        if await context.prevState == .updateSubtreeRoots || now - lastChainTipUpdateTime > 600 {
+            await downloader.stopDownload()
+            try await updateChainTip(context, time: now)
+            await context.update(state: .clearCache)
+        } else if await context.prevState == .enhance {
+            await context.update(state: .download)
+        }
+        
+        return context
+    }
+
+    func stop() async { }
+}

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

@@ -0,0 +1,58 @@
+//
+//  UpdateSubtreeRootsAction.swift
+//  
+//
+//  Created by Lukas Korba on 01.08.2023.
+//
+
+import Foundation
+
+final class UpdateSubtreeRootsAction {
+    let configProvider: CompactBlockProcessor.ConfigProvider
+    let rustBackend: ZcashRustBackendWelding
+    let service: LightWalletService
+    let logger: Logger
+    
+    init(container: DIContainer, configProvider: CompactBlockProcessor.ConfigProvider) {
+        self.configProvider = configProvider
+        service = container.resolve(LightWalletService.self)
+        rustBackend = container.resolve(ZcashRustBackendWelding.self)
+        logger = container.resolve(Logger.self)
+    }
+}
+
+extension UpdateSubtreeRootsAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        var request = GetSubtreeRootsArg()
+        request.shieldedProtocol = .sapling
+        
+        logger.info("Attempt to get subtree roots, this may fail because lightwalletd may not support Spend before Sync.")
+        let stream = service.getSubtreeRoots(request)
+        
+        var roots: [SubtreeRoot] = []
+        
+        do {
+            for try await subtreeRoot in stream {
+                roots.append(subtreeRoot)
+            }
+        } catch ZcashError.serviceSubtreeRootsStreamFailed(LightWalletServiceError.timeOut) {
+            throw ZcashError.serviceSubtreeRootsStreamFailed(LightWalletServiceError.timeOut)
+        }
+
+        logger.info("Sapling tree has \(roots.count) subtrees")
+        do {
+            try await rustBackend.putSaplingSubtreeRoots(startIndex: UInt64(request.startIndex), roots: roots)
+            
+            await context.update(state: .updateChainTip)
+        } catch {
+            logger.debug("putSaplingSubtreeRoots failed with error \(error.localizedDescription)")
+            throw ZcashError.compactBlockProcessorPutSaplingSubtreeRoots(error)
+        }
+        
+        return context
+    }
+
+    func stop() async { }
+}

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

@@ -0,0 +1,60 @@
+//
+//  ValidateServerAction.swift
+//  
+//
+//  Created by Michal Fousek on 05.05.2023.
+//
+
+import Foundation
+
+final class ValidateServerAction {
+    let configProvider: CompactBlockProcessor.ConfigProvider
+    let rustBackend: ZcashRustBackendWelding
+    let service: LightWalletService
+
+    init(container: DIContainer, configProvider: CompactBlockProcessor.ConfigProvider) {
+        self.configProvider = configProvider
+        rustBackend = container.resolve(ZcashRustBackendWelding.self)
+        service = container.resolve(LightWalletService.self)
+    }
+}
+
+extension ValidateServerAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    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()
+        let localNetwork = config.network
+        let saplingActivation = config.saplingActivation
+
+        // check network types
+        guard let remoteNetworkType = NetworkType.forChainName(info.chainName) else {
+            throw ZcashError.compactBlockProcessorChainName(info.chainName)
+        }
+
+        guard remoteNetworkType == localNetwork.networkType else {
+            throw ZcashError.compactBlockProcessorNetworkMismatch(localNetwork.networkType, remoteNetworkType)
+        }
+
+        guard saplingActivation == info.saplingActivationHeight else {
+            throw ZcashError.compactBlockProcessorSaplingActivationMismatch(saplingActivation, BlockHeight(info.saplingActivationHeight))
+        }
+
+        // check branch id
+        let localBranch = try rustBackend.consensusBranchIdFor(height: Int32(info.blockHeight))
+
+        guard let remoteBranchID = ConsensusBranchID.fromString(info.consensusBranchID) else {
+            throw ZcashError.compactBlockProcessorConsensusBranchID
+        }
+
+        guard remoteBranchID == localBranch else {
+            throw ZcashError.compactBlockProcessorWrongConsensusBranchId(localBranch, remoteBranchID)
+        }
+
+        await context.update(state: .fetchUTXO)
+        return context
+    }
+
+    func stop() async { }
+}