react-native-zcash 0.6.10 → 0.6.11

package/ios/ZCashLightClientKit/Synchronizer/ClosureSDKSynchronizer.swift

@@ -33,12 +33,12 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
 
     public func prepare(
         with seed: [UInt8]?,
+        viewingKeys: [UnifiedFullViewingKey],
         walletBirthday: BlockHeight,
-        for walletMode: WalletInitMode,
         completion: @escaping (Result<Initializer.InitializationResult, Error>) -> Void
     ) {
         AsyncToClosureGateway.executeThrowingAction(completion) {
-            return try await self.synchronizer.prepare(with: seed, walletBirthday: walletBirthday, for: walletMode)
+            return try await self.synchronizer.prepare(with: seed, viewingKeys: viewingKeys, walletBirthday: walletBirthday)
         }
     }
 
@@ -93,6 +93,12 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
         }
     }
 
+    public func pendingTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void) {
+        AsyncToClosureGateway.executeAction(completion) {
+            await self.synchronizer.pendingTransactions
+        }
+    }
+
     public func clearedTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void) {
         AsyncToClosureGateway.executeAction(completion) {
             await self.synchronizer.transactions

package/ios/ZCashLightClientKit/Synchronizer/CombineSDKSynchronizer.swift

@@ -33,11 +33,11 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
 
     public func prepare(
         with seed: [UInt8]?,
-        walletBirthday: BlockHeight,
-        for walletMode: WalletInitMode
+        viewingKeys: [UnifiedFullViewingKey],
+        walletBirthday: BlockHeight
     ) -> SinglePublisher<Initializer.InitializationResult, Error> {
         AsyncToCombineGateway.executeThrowingAction() {
-            return try await self.synchronizer.prepare(with: seed, walletBirthday: walletBirthday, for: walletMode)
+            return try await self.synchronizer.prepare(with: seed, viewingKeys: viewingKeys, walletBirthday: walletBirthday)
         }
     }
 
@@ -90,6 +90,12 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
         }
     }
 
+    public var pendingTransactions: AnyPublisher<[ZcashTransaction.Overview], Never> {
+        AsyncToCombineGateway.executeAction() {
+            await self.synchronizer.pendingTransactions
+        }
+    }
+
     public var allTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> {
         AsyncToCombineGateway.executeAction() {
             await self.synchronizer.transactions
@@ -122,6 +128,12 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
         }
     }
 
+    public func allPendingTransactions() -> AnyPublisher<[ZcashTransaction.Overview], Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.allPendingTransactions()
+        }
+    }
+
     public func allTransactions(from transaction: ZcashTransaction.Overview, limit: Int) -> SinglePublisher<[ZcashTransaction.Overview], Error> {
         AsyncToCombineGateway.executeThrowingAction() {
             try await self.synchronizer.allTransactions(from: transaction, limit: limit)

package/ios/ZCashLightClientKit/Synchronizer/Dependencies.swift

@@ -14,8 +14,7 @@ enum Dependencies {
         alias: ZcashSynchronizerAlias,
         networkType: NetworkType,
         endpoint: LightWalletEndpoint,
-        loggingPolicy: Initializer.LoggingPolicy = .default(.debug),
-        enableBackendTracing: Bool = false
+        loggingPolicy: Initializer.LoggingPolicy = .default(.debug)
     ) {
         container.register(type: Logger.self, isSingleton: true) { _ in
             let logger: Logger
@@ -37,8 +36,7 @@ enum Dependencies {
                 fsBlockDbRoot: urls.fsBlockDbRoot,
                 spendParamsPath: urls.spendParamsURL,
                 outputParamsPath: urls.outputParamsURL,
-                networkType: networkType,
-                enableTracing: enableBackendTracing
+                networkType: networkType
             )
         }
 
@@ -80,17 +78,18 @@ enum Dependencies {
 
         container.register(type: LatestBlocksDataProvider.self, isSingleton: true) { di in
             let service = di.resolve(LightWalletService.self)
-            let rustBackend = di.resolve(ZcashRustBackendWelding.self)
+            let transactionRepository = di.resolve(TransactionRepository.self)
 
-            return LatestBlocksDataProviderImpl(service: service, rustBackend: rustBackend)
+            return LatestBlocksDataProviderImpl(service: service, transactionRepository: transactionRepository)
         }
 
         container.register(type: SyncSessionIDGenerator.self, isSingleton: false) { _ in
             UniqueSyncSessionIDGenerator()
         }
-        
-        container.register(type: ZcashFileManager.self, isSingleton: true) { _ in
-            FileManager.default
+
+        container.register(type: InternalSyncProgress.self, isSingleton: true) { di in
+            let logger = di.resolve(Logger.self)
+            return InternalSyncProgress(alias: alias, storage: UserDefaults.standard, logger: logger)
         }
     }
     
@@ -103,6 +102,7 @@ enum Dependencies {
             let service = di.resolve(LightWalletService.self)
             let blockDownloaderService = di.resolve(BlockDownloaderService.self)
             let storage = di.resolve(CompactBlockRepository.self)
+            let internalSyncProgress = di.resolve(InternalSyncProgress.self)
             let metrics = di.resolve(SDKMetrics.self)
             let logger = di.resolve(Logger.self)
 
@@ -110,6 +110,19 @@ enum Dependencies {
                 service: service,
                 downloaderService: blockDownloaderService,
                 storage: storage,
+                internalSyncProgress: internalSyncProgress,
+                metrics: metrics,
+                logger: logger
+            )
+        }
+        
+        container.register(type: BlockValidator.self, isSingleton: true) { di in
+            let rustBackend = di.resolve(ZcashRustBackendWelding.self)
+            let metrics = di.resolve(SDKMetrics.self)
+            let logger = di.resolve(Logger.self)
+
+            return BlockValidatorImpl(
+                rustBackend: rustBackend,
                 metrics: metrics,
                 logger: logger
             )
@@ -120,10 +133,11 @@ enum Dependencies {
             let transactionRepository = di.resolve(TransactionRepository.self)
             let metrics = di.resolve(SDKMetrics.self)
             let logger = di.resolve(Logger.self)
+            let latestBlocksDataProvider = di.resolve(LatestBlocksDataProvider.self)
 
             let blockScannerConfig = BlockScannerConfig(
                 networkType: config.network.networkType,
-                scanningBatchSize: config.batchSize
+                scanningBatchSize: config.scanningBatchSize
             )
 
             return BlockScannerImpl(
@@ -131,12 +145,14 @@ enum Dependencies {
                 rustBackend: rustBackend,
                 transactionRepository: transactionRepository,
                 metrics: metrics,
-                logger: logger
+                logger: logger,
+                latestBlocksDataProvider: latestBlocksDataProvider
             )
         }
         
         container.register(type: BlockEnhancer.self, isSingleton: true) { di in
             let blockDownloaderService = di.resolve(BlockDownloaderService.self)
+            let internalSyncProgress = di.resolve(InternalSyncProgress.self)
             let rustBackend = di.resolve(ZcashRustBackendWelding.self)
             let transactionRepository = di.resolve(TransactionRepository.self)
             let metrics = di.resolve(SDKMetrics.self)
@@ -144,6 +160,7 @@ enum Dependencies {
 
             return BlockEnhancerImpl(
                 blockDownloaderService: blockDownloaderService,
+                internalSyncProgress: internalSyncProgress,
                 rustBackend: rustBackend,
                 transactionRepository: transactionRepository,
                 metrics: metrics,
@@ -154,6 +171,7 @@ enum Dependencies {
         container.register(type: UTXOFetcher.self, isSingleton: true) { di in
             let blockDownloaderService = di.resolve(BlockDownloaderService.self)
             let utxoFetcherConfig = UTXOFetcherConfig(walletBirthdayProvider: config.walletBirthdayProvider)
+            let internalSyncProgress = di.resolve(InternalSyncProgress.self)
             let rustBackend = di.resolve(ZcashRustBackendWelding.self)
             let metrics = di.resolve(SDKMetrics.self)
             let logger = di.resolve(Logger.self)
@@ -162,6 +180,7 @@ enum Dependencies {
                 accountRepository: accountRepository,
                 blockDownloaderService: blockDownloaderService,
                 config: utxoFetcherConfig,
+                internalSyncProgress: internalSyncProgress,
                 rustBackend: rustBackend,
                 metrics: metrics,
                 logger: logger

package/ios/ZCashLightClientKit/Synchronizer/SDKSynchronizer.swift

@@ -24,7 +24,7 @@ public class SDKSynchronizer: Synchronizer {
 
     public let metrics: SDKMetrics
     public let logger: Logger
-
+    
     // Don't read this variable directly. Use `status` instead. And don't update this variable directly use `updateStatus()` methods instead.
     private var underlyingStatus: GenericActor<InternalSyncStatus>
     var status: InternalSyncStatus {
@@ -102,9 +102,9 @@ public class SDKSynchronizer: Synchronizer {
         }
     }
 
-    func updateStatus(_ newValue: InternalSyncStatus, updateExternalStatus: Bool = true) async {
+    func updateStatus(_ newValue: InternalSyncStatus) async {
         let oldValue = await underlyingStatus.update(newValue)
-        await notify(oldStatus: oldValue, newStatus: newValue, updateExternalStatus: updateExternalStatus)
+        await notify(oldStatus: oldValue, newStatus: newValue)
     }
 
     func throwIfUnprepared() throws {
@@ -127,8 +127,8 @@ public class SDKSynchronizer: Synchronizer {
 
     public func prepare(
         with seed: [UInt8]?,
-        walletBirthday: BlockHeight,
-        for walletMode: WalletInitMode
+        viewingKeys: [UnifiedFullViewingKey],
+        walletBirthday: BlockHeight
     ) async throws -> Initializer.InitializationResult {
         guard await status == .unprepared else { return .success }
 
@@ -138,14 +138,14 @@ public class SDKSynchronizer: Synchronizer {
 
         try await utxoRepository.initialise()
 
-        if case .seedRequired = try await self.initializer.initialize(with: seed, walletBirthday: walletBirthday, for: walletMode) {
+        if case .seedRequired = try await self.initializer.initialize(with: seed, viewingKeys: viewingKeys, walletBirthday: walletBirthday) {
             return .seedRequired
         }
-        
+
         await latestBlocksDataProvider.updateWalletBirthday(initializer.walletBirthday)
         await latestBlocksDataProvider.updateScannedData()
         
-        await updateStatus(.disconnected, updateExternalStatus: false)
+        await updateStatus(.disconnected)
 
         return .success
     }
@@ -157,14 +157,14 @@ public class SDKSynchronizer: Synchronizer {
         case .unprepared:
             throw ZcashError.synchronizerNotPrepared
 
-        case .syncing:
+        case .syncing, .enhancing, .fetching:
             logger.warn("warning: Synchronizer started when already running. Next sync process will be started when the current one stops.")
             /// This may look strange but `CompactBlockProcessor` has mechanisms which can handle this situation. So we are fine with calling
             /// it's start here.
             await blockProcessor.start(retry: retry)
 
         case .stopped, .synced, .disconnected, .error:
-            await updateStatus(.syncing(0))
+            await updateStatus(.syncing(.nullProgress))
             syncStartDate = Date()
             await blockProcessor.start(retry: retry)
         }
@@ -197,14 +197,15 @@ public class SDKSynchronizer: Synchronizer {
 
     // MARK: Handle CompactBlockProcessor.Flow
 
+    // swiftlint:disable:next cyclomatic_complexity
     private func subscribeToProcessorEvents(_ processor: CompactBlockProcessor) async {
         let eventClosure: CompactBlockProcessor.EventClosure = { [weak self] event in
             switch event {
             case let .failed(error):
                 await self?.failed(error: error)
 
-            case let .finished(height):
-                await self?.finished(lastScannedHeight: height)
+            case let .finished(height, foundBlocks):
+                await self?.finished(lastScannedHeight: height, foundBlocks: foundBlocks)
 
             case let .foundTransactions(transactions, range):
                 self?.foundTransactions(transactions: transactions, in: range)
@@ -216,14 +217,17 @@ public class SDKSynchronizer: Synchronizer {
             case let .progressUpdated(progress):
                 await self?.progressUpdated(progress: progress)
 
-            case .syncProgress:
-                break
-                
             case let .storedUTXOs(utxos):
                 self?.storedUTXOs(utxos: utxos)
 
-            case .startedEnhancing, .startedFetching, .startedSyncing:
-                break
+            case .startedEnhancing:
+                await self?.updateStatus(.enhancing(.zero))
+
+            case .startedFetching:
+                await self?.updateStatus(.fetching(0))
+
+            case .startedSyncing:
+                await self?.updateStatus(.syncing(.nullProgress))
 
             case .stopped:
                 await self?.updateStatus(.stopped)
@@ -240,7 +244,7 @@ public class SDKSynchronizer: Synchronizer {
         await updateStatus(.error(error))
     }
 
-    private func finished(lastScannedHeight: BlockHeight) async {
+    private func finished(lastScannedHeight: BlockHeight, foundBlocks: Bool) async {
         await latestBlocksDataProvider.updateScannedData()
 
         await updateStatus(.synced)
@@ -259,7 +263,7 @@ public class SDKSynchronizer: Synchronizer {
         }
     }
 
-    private func progressUpdated(progress: Float) async {
+    private func progressUpdated(progress: CompactBlockProgress) async {
         let newStatus = InternalSyncStatus(progress)
         await updateStatus(newStatus)
     }
@@ -311,8 +315,8 @@ public class SDKSynchronizer: Synchronizer {
         let accountIndex = Int(spendingKey.account)
         let tBalance = try await self.getTransparentBalance(accountIndex: accountIndex)
 
-        // Verify that at least there are funds for the fee. Ideally this logic will be improved by the shielding wallet.
-        guard tBalance.verified >= self.network.constants.defaultFee() else {
+        // Verify that at least there are funds for the fee. Ideally this logic will be improved by the shielding   wallet.
+        guard tBalance.verified >= self.network.constants.defaultFee(for: await self.latestBlocksDataProvider.latestScannedHeight) else {
             throw ZcashError.synchronizerShieldFundsInsuficientTransparentFunds
         }
 
@@ -365,6 +369,12 @@ public class SDKSynchronizer: Synchronizer {
         try await transactionRepository.findReceived(offset: 0, limit: Int.max)
     }
 
+    public func allPendingTransactions() async throws -> [ZcashTransaction.Overview] {
+        let latestScannedHeight = self.latestState.latestScannedHeight
+        
+        return try await transactionRepository.findPendingTransactions(latestHeight: latestScannedHeight, offset: 0, limit: .max)
+    }
+
     public func allTransactions() async throws -> [ZcashTransaction.Overview] {
         return try await transactionRepository.find(offset: 0, limit: Int.max, kind: .all)
     }
@@ -386,15 +396,15 @@ public class SDKSynchronizer: Synchronizer {
     }
 
     public func getRecipients(for transaction: ZcashTransaction.Overview) async -> [TransactionRecipient] {
-        return (try? await transactionRepository.getRecipients(for: transaction.rawID)) ?? []
+        return (try? await transactionRepository.getRecipients(for: transaction.id)) ?? []
     }
 
     public func getTransactionOutputs(for transaction: ZcashTransaction.Overview) async -> [ZcashTransaction.Output] {
-        return (try? await transactionRepository.getTransactionOutputs(for: transaction.rawID)) ?? []
+        return (try? await transactionRepository.getTransactionOutputs(for: transaction.id)) ?? []
     }
 
     public func latestHeight() async throws -> BlockHeight {
-        try await blockProcessor.latestHeight()
+        try await blockProcessor.blockDownloaderService.latestBlockHeight()
     }
 
     public func latestUTXOs(address: String) async throws -> [UnspentTransactionOutputEntity] {
@@ -493,11 +503,7 @@ public class SDKSynchronizer: Synchronizer {
                 }
             )
 
-            do {
-                try await blockProcessor.rewind(context: context)
-            } catch {
-                subject.send(completion: .failure(error))
-            }
+            await blockProcessor.rewind(context: context)
         }
         return subject.eraseToAnyPublisher()
     }
@@ -527,16 +533,12 @@ public class SDKSynchronizer: Synchronizer {
                 }
             )
 
-            do {
-                try await blockProcessor.wipe(context: context)
-            } catch {
-                subject.send(completion: .failure(error))
-            }
+            await blockProcessor.wipe(context: context)
         }
 
         return subject.eraseToAnyPublisher()
     }
-    
+
     // MARK: notify state
 
     private func snapshotState(status: InternalSyncStatus) async -> SynchronizerState {
@@ -548,11 +550,13 @@ public class SDKSynchronizer: Synchronizer {
             ),
             transparentBalance: (try? await blockProcessor.getTransparentBalance(accountIndex: 0)) ?? .zero,
             internalSyncStatus: status,
-            latestBlockHeight: latestBlocksDataProvider.latestBlockHeight
+            latestScannedHeight: latestBlocksDataProvider.latestScannedHeight,
+            latestBlockHeight: latestBlocksDataProvider.latestBlockHeight,
+            latestScannedTime: latestBlocksDataProvider.latestScannedTime
         )
     }
 
-    private func notify(oldStatus: InternalSyncStatus, newStatus: InternalSyncStatus, updateExternalStatus: Bool = true) async {
+    private func notify(oldStatus: InternalSyncStatus, newStatus: InternalSyncStatus) async {
         guard oldStatus != newStatus else { return }
 
         let newState: SynchronizerState
@@ -575,10 +579,7 @@ public class SDKSynchronizer: Synchronizer {
         }
 
         latestState = newState
-
-        if updateExternalStatus {
-            updateStateStream(with: latestState)
-        }
+        updateStateStream(with: latestState)
     }
 
     private func updateStateStream(with newState: SynchronizerState) {
@@ -612,6 +613,12 @@ extension SDKSynchronizer {
             (try? await allReceivedTransactions()) ?? []
         }
     }
+
+    public var pendingTransactions: [ZcashTransaction.Overview] {
+        get async {
+            (try? await allPendingTransactions()) ?? []
+        }
+    }
 }
 
 extension InternalSyncStatus {
@@ -619,6 +626,8 @@ extension InternalSyncStatus {
         switch (self, otherStatus) {
         case (.unprepared, .unprepared): return false
         case (.syncing, .syncing): return false
+        case (.enhancing, .enhancing): return false
+        case (.fetching, .fetching): return false
         case (.synced, .synced): return false
         case (.stopped, .stopped): return false
         case (.disconnected, .disconnected): return false