react-native-zcash 0.4.2 → 0.6.0

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,59 @@
+//
+//  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(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")
+    }
+}

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 { }
+}