react-native-zcash 0.6.11 → 0.6.12

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