react-native-zcash 0.4.2 → 0.6.0

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, viewingKeys: viewingKeys, walletBirthday: walletBirthday)
+            return try await self.synchronizer.prepare(with: seed, walletBirthday: walletBirthday, for: walletMode)
         }
     }
 
@@ -93,12 +93,6 @@ 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]?,
-        viewingKeys: [UnifiedFullViewingKey],
-        walletBirthday: BlockHeight
+        walletBirthday: BlockHeight,
+        for walletMode: WalletInitMode
     ) -> SinglePublisher<Initializer.InitializationResult, Error> {
         AsyncToCombineGateway.executeThrowingAction() {
-            return try await self.synchronizer.prepare(with: seed, viewingKeys: viewingKeys, walletBirthday: walletBirthday)
+            return try await self.synchronizer.prepare(with: seed, walletBirthday: walletBirthday, for: walletMode)
         }
     }
 
@@ -90,12 +90,6 @@ 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
@@ -128,12 +122,6 @@ 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,7 +14,8 @@ enum Dependencies {
         alias: ZcashSynchronizerAlias,
         networkType: NetworkType,
         endpoint: LightWalletEndpoint,
-        loggingPolicy: Initializer.LoggingPolicy = .default(.debug)
+        loggingPolicy: Initializer.LoggingPolicy = .default(.debug),
+        enableBackendTracing: Bool = false
     ) {
         container.register(type: Logger.self, isSingleton: true) { _ in
             let logger: Logger
@@ -36,7 +37,8 @@ enum Dependencies {
                 fsBlockDbRoot: urls.fsBlockDbRoot,
                 spendParamsPath: urls.spendParamsURL,
                 outputParamsPath: urls.outputParamsURL,
-                networkType: networkType
+                networkType: networkType,
+                enableTracing: enableBackendTracing
             )
         }
 
@@ -78,18 +80,17 @@ enum Dependencies {
 
         container.register(type: LatestBlocksDataProvider.self, isSingleton: true) { di in
             let service = di.resolve(LightWalletService.self)
-            let transactionRepository = di.resolve(TransactionRepository.self)
+            let rustBackend = di.resolve(ZcashRustBackendWelding.self)
 
-            return LatestBlocksDataProviderImpl(service: service, transactionRepository: transactionRepository)
+            return LatestBlocksDataProviderImpl(service: service, rustBackend: rustBackend)
         }
 
         container.register(type: SyncSessionIDGenerator.self, isSingleton: false) { _ in
             UniqueSyncSessionIDGenerator()
         }
-
-        container.register(type: InternalSyncProgress.self, isSingleton: true) { di in
-            let logger = di.resolve(Logger.self)
-            return InternalSyncProgress(alias: alias, storage: UserDefaults.standard, logger: logger)
+        
+        container.register(type: ZcashFileManager.self, isSingleton: true) { _ in
+            FileManager.default
         }
     }
     
@@ -102,7 +103,6 @@ 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,19 +110,6 @@ 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
             )
@@ -133,11 +120,10 @@ 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.scanningBatchSize
+                scanningBatchSize: config.batchSize
             )
 
             return BlockScannerImpl(
@@ -145,14 +131,12 @@ enum Dependencies {
                 rustBackend: rustBackend,
                 transactionRepository: transactionRepository,
                 metrics: metrics,
-                logger: logger,
-                latestBlocksDataProvider: latestBlocksDataProvider
+                logger: logger
             )
         }
         
         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)
@@ -160,7 +144,6 @@ enum Dependencies {
 
             return BlockEnhancerImpl(
                 blockDownloaderService: blockDownloaderService,
-                internalSyncProgress: internalSyncProgress,
                 rustBackend: rustBackend,
                 transactionRepository: transactionRepository,
                 metrics: metrics,
@@ -171,7 +154,6 @@ 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)
@@ -180,7 +162,6 @@ 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) async {
+    func updateStatus(_ newValue: InternalSyncStatus, updateExternalStatus: Bool = true) async {
         let oldValue = await underlyingStatus.update(newValue)
-        await notify(oldStatus: oldValue, newStatus: newValue)
+        await notify(oldStatus: oldValue, newStatus: newValue, updateExternalStatus: updateExternalStatus)
     }
 
     func throwIfUnprepared() throws {
@@ -127,8 +127,8 @@ public class SDKSynchronizer: Synchronizer {
 
     public func prepare(
         with seed: [UInt8]?,
-        viewingKeys: [UnifiedFullViewingKey],
-        walletBirthday: BlockHeight
+        walletBirthday: BlockHeight,
+        for walletMode: WalletInitMode
     ) 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, viewingKeys: viewingKeys, walletBirthday: walletBirthday) {
+        if case .seedRequired = try await self.initializer.initialize(with: seed, walletBirthday: walletBirthday, for: walletMode) {
             return .seedRequired
         }
-
+        
         await latestBlocksDataProvider.updateWalletBirthday(initializer.walletBirthday)
         await latestBlocksDataProvider.updateScannedData()
         
-        await updateStatus(.disconnected)
+        await updateStatus(.disconnected, updateExternalStatus: false)
 
         return .success
     }
@@ -157,14 +157,14 @@ public class SDKSynchronizer: Synchronizer {
         case .unprepared:
             throw ZcashError.synchronizerNotPrepared
 
-        case .syncing, .enhancing, .fetching:
+        case .syncing:
             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(.nullProgress))
+            await updateStatus(.syncing(0))
             syncStartDate = Date()
             await blockProcessor.start(retry: retry)
         }
@@ -197,15 +197,14 @@ 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, foundBlocks):
-                await self?.finished(lastScannedHeight: height, foundBlocks: foundBlocks)
+            case let .finished(height):
+                await self?.finished(lastScannedHeight: height)
 
             case let .foundTransactions(transactions, range):
                 self?.foundTransactions(transactions: transactions, in: range)
@@ -217,17 +216,14 @@ 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:
-                await self?.updateStatus(.enhancing(.zero))
-
-            case .startedFetching:
-                await self?.updateStatus(.fetching(0))
-
-            case .startedSyncing:
-                await self?.updateStatus(.syncing(.nullProgress))
+            case .startedEnhancing, .startedFetching, .startedSyncing:
+                break
 
             case .stopped:
                 await self?.updateStatus(.stopped)
@@ -244,7 +240,7 @@ public class SDKSynchronizer: Synchronizer {
         await updateStatus(.error(error))
     }
 
-    private func finished(lastScannedHeight: BlockHeight, foundBlocks: Bool) async {
+    private func finished(lastScannedHeight: BlockHeight) async {
         await latestBlocksDataProvider.updateScannedData()
 
         await updateStatus(.synced)
@@ -263,7 +259,7 @@ public class SDKSynchronizer: Synchronizer {
         }
     }
 
-    private func progressUpdated(progress: CompactBlockProgress) async {
+    private func progressUpdated(progress: Float) async {
         let newStatus = InternalSyncStatus(progress)
         await updateStatus(newStatus)
     }
@@ -315,8 +311,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(for: await self.latestBlocksDataProvider.latestScannedHeight) 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() else {
             throw ZcashError.synchronizerShieldFundsInsuficientTransparentFunds
         }
 
@@ -369,12 +365,6 @@ 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)
     }
@@ -396,15 +386,15 @@ public class SDKSynchronizer: Synchronizer {
     }
 
     public func getRecipients(for transaction: ZcashTransaction.Overview) async -> [TransactionRecipient] {
-        return (try? await transactionRepository.getRecipients(for: transaction.id)) ?? []
+        return (try? await transactionRepository.getRecipients(for: transaction.rawID)) ?? []
     }
 
     public func getTransactionOutputs(for transaction: ZcashTransaction.Overview) async -> [ZcashTransaction.Output] {
-        return (try? await transactionRepository.getTransactionOutputs(for: transaction.id)) ?? []
+        return (try? await transactionRepository.getTransactionOutputs(for: transaction.rawID)) ?? []
     }
 
     public func latestHeight() async throws -> BlockHeight {
-        try await blockProcessor.blockDownloaderService.latestBlockHeight()
+        try await blockProcessor.latestHeight()
     }
 
     public func latestUTXOs(address: String) async throws -> [UnspentTransactionOutputEntity] {
@@ -503,7 +493,11 @@ public class SDKSynchronizer: Synchronizer {
                 }
             )
 
-            await blockProcessor.rewind(context: context)
+            do {
+                try await blockProcessor.rewind(context: context)
+            } catch {
+                subject.send(completion: .failure(error))
+            }
         }
         return subject.eraseToAnyPublisher()
     }
@@ -533,12 +527,16 @@ public class SDKSynchronizer: Synchronizer {
                 }
             )
 
-            await blockProcessor.wipe(context: context)
+            do {
+                try await blockProcessor.wipe(context: context)
+            } catch {
+                subject.send(completion: .failure(error))
+            }
         }
 
         return subject.eraseToAnyPublisher()
     }
-
+    
     // MARK: notify state
 
     private func snapshotState(status: InternalSyncStatus) async -> SynchronizerState {
@@ -550,13 +548,11 @@ public class SDKSynchronizer: Synchronizer {
             ),
             transparentBalance: (try? await blockProcessor.getTransparentBalance(accountIndex: 0)) ?? .zero,
             internalSyncStatus: status,
-            latestScannedHeight: latestBlocksDataProvider.latestScannedHeight,
-            latestBlockHeight: latestBlocksDataProvider.latestBlockHeight,
-            latestScannedTime: latestBlocksDataProvider.latestScannedTime
+            latestBlockHeight: latestBlocksDataProvider.latestBlockHeight
         )
     }
 
-    private func notify(oldStatus: InternalSyncStatus, newStatus: InternalSyncStatus) async {
+    private func notify(oldStatus: InternalSyncStatus, newStatus: InternalSyncStatus, updateExternalStatus: Bool = true) async {
         guard oldStatus != newStatus else { return }
 
         let newState: SynchronizerState
@@ -579,7 +575,10 @@ public class SDKSynchronizer: Synchronizer {
         }
 
         latestState = newState
-        updateStateStream(with: latestState)
+
+        if updateExternalStatus {
+            updateStateStream(with: latestState)
+        }
     }
 
     private func updateStateStream(with newState: SynchronizerState) {
@@ -613,12 +612,6 @@ extension SDKSynchronizer {
             (try? await allReceivedTransactions()) ?? []
         }
     }
-
-    public var pendingTransactions: [ZcashTransaction.Overview] {
-        get async {
-            (try? await allPendingTransactions()) ?? []
-        }
-    }
 }
 
 extension InternalSyncStatus {
@@ -626,8 +619,6 @@ 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