react-native-zcash 0.6.11 → 0.6.13

package/ios/ZCashLightClientKit/Rust/ZcashRustBackendWelding.swift

@@ -35,9 +35,11 @@ protocol ZcashRustBackendWelding {
     /// have been received by the currently-available account (in order to enable
     /// automated account recovery).
     /// - parameter seed: byte array of the zip32 seed
+    /// - parameter treeState: The TreeState Protobuf object for the height prior to the account birthday
+    /// - parameter recoverUntil: the fully-scanned height up to which the account will be treated as "being recovered"
     /// - Returns: The `UnifiedSpendingKey` structs for the number of accounts created
     /// - Throws: `rustCreateAccount`.
-    func createAccount(seed: [UInt8]) async throws -> UnifiedSpendingKey
+    func createAccount(seed: [UInt8], treeState: TreeState, recoverUntil: UInt32?) async throws -> UnifiedSpendingKey
 
     /// Creates a transaction to the given address from the given account
     /// - Parameter usk: `UnifiedSpendingKey` for the account that controls the funds to be spent.
@@ -50,7 +52,7 @@ protocol ZcashRustBackendWelding {
         to address: String,
         value: Int64,
         memo: MemoBytes?
-    ) async throws -> Int64
+    ) async throws -> Data
 
     /// Scans a transaction for any information that can be decrypted by the accounts in the wallet, and saves it to the wallet.
     /// - parameter tx:     the transaction to decrypt
@@ -89,14 +91,10 @@ protocol ZcashRustBackendWelding {
     ///     - `rustGetNextAvailableAddressInvalidAddress` if generated unified address isn't valid.
     func getNextAvailableAddress(account: Int32) async throws -> UnifiedAddress
 
-    /// Get received memo from note.
-    /// - parameter idNote: note_id of note where the memo is located
-    func getReceivedMemo(idNote: Int64) async -> Memo?
-
-    /// Get sent memo from note.
-    /// - parameter idNote: note_id of note where the memo is located
-    /// - Returns: a `Memo` if any
-    func getSentMemo(idNote: Int64) async -> Memo?
+    /// Get memo from note.
+    /// - parameter txId: ID of transaction containing the note
+    /// - parameter outputIndex: output index of note
+    func getMemo(txId: Data, outputIndex: UInt16) async throws -> Memo?
 
     /// Get the verified cached transparent balance for the given address
     /// - parameter account; the account index to query
@@ -105,14 +103,6 @@ protocol ZcashRustBackendWelding {
     ///     - `rustGetTransparentBalance` if rust layer returns error.
     func getTransparentBalance(account: Int32) async throws -> Int64
 
-    /// Initialize the accounts table from a set of unified full viewing keys.
-    /// - Note: this function should only be used when restoring an existing seed phrase. when creating a new wallet, use `createAccount()` instead.
-    /// - Parameter ufvks: an array of UnifiedFullViewingKeys
-    /// - Throws:
-    ///     - `rustInitAccountsTableViewingKeyCotainsNullBytes` if any of the key in `ufvks` contains null bytes before end.
-    ///     - `rustInitAccountsTableViewingKeyIsInvalid` if any of the key in `ufvks` isn't valid.
-    func initAccountsTable(ufvks: [UnifiedFullViewingKey]) async throws
-
     /// Initializes the data db. This will performs any migrations needed on the sqlite file
     /// provided. Some migrations might need that callers provide the seed bytes.
     /// - Parameter seed: ZIP-32 compliant seed bytes for this wallet
@@ -122,23 +112,6 @@ protocol ZcashRustBackendWelding {
     /// Throws `rustInitDataDb` if rust layer returns error.
     func initDataDb(seed: [UInt8]?) async throws -> DbInitResult
 
-    /// Initialize the blocks table from a given checkpoint (heigh, hash, time, saplingTree and networkType).
-    /// - parameter height: represents the block height of the given checkpoint
-    /// - parameter hash: hash of the merkle tree
-    /// - parameter time: in milliseconds from reference
-    /// - parameter saplingTree: hash of the sapling tree
-    /// - Throws:
-    ///     - `rustInitBlocksTableHashContainsNullBytes` if `hash` contains null bytes before end.
-    ///     - `rustInitBlocksTableSaplingTreeContainsNullBytes` if `saplingTree` contains null bytes before end.
-    ///     - `rustInitBlocksTableDataDbNotEmpty` if data DB is not empty.
-    ///     - `rustInitBlocksTable` if rust layer returns error.
-    func initBlocksTable(
-        height: Int32,
-        hash: String,
-        time: UInt32,
-        saplingTree: String
-    ) async throws
-
     /// Returns a list of the transparent receivers for the diversified unified addresses that have
     /// been allocated for the provided account.
     /// - parameter account: index of the given account
@@ -159,26 +132,6 @@ protocol ZcashRustBackendWelding {
     ///     - `rustGetVerifiedTransparentBalance` if rust layer returns error.
     func getVerifiedTransparentBalance(account: Int32) async throws -> Int64
 
-    /// Checks that the scanned blocks in the data database, when combined with the recent
-    /// `CompactBlock`s in the cache database, form a valid chain.
-    /// This function is built on the core assumption that the information provided in the
-    /// cache database is more likely to be accurate than the previously-scanned information.
-    /// This follows from the design (and trust) assumption that the `lightwalletd` server
-    /// provides accurate block information as of the time it was requested.
-    /// - parameter fsBlockDbRoot: `URL` pointing to the filesystem root directory where the fsBlock cache is.
-    /// this directory  is expected to contain a `/blocks` sub-directory with the blocks stored in the convened filename
-    /// format `{height}-{hash}-block`. This directory has must be granted both write and read permissions.
-    /// - parameter dbData: location of the data db file
-    /// - parameter networkType: the network type
-    /// - parameter limit: a limit to validate a fixed number of blocks instead of the whole cache.
-    /// - Throws:
-    ///  - `rustValidateCombinedChainValidationFailed` if there was an error during validation unrelated to chain validity.
-    ///  - `rustValidateCombinedChainInvalidChain(upperBound)` if the combined chain is invalid. `upperBound` is the height of the highest invalid
-    ///    block(on the assumption that the highest block in the cache database is correct).
-    ///
-    /// - Important: This function does not mutate either of the databases.
-    func validateCombinedChain(limit: UInt32) async throws
-
     /// Resets the state of the database to only contain block and transaction information up to the given height. clears up all derived data as well
     /// - parameter height: height to rewind to.
     /// - Throws: `rustRewindToHeight` if rust layer returns error.
@@ -190,21 +143,62 @@ protocol ZcashRustBackendWelding {
     /// - Throws: `rustRewindCacheToHeight` if rust layer returns error.
     func rewindCacheToHeight(height: Int32) async throws
 
+    func putSaplingSubtreeRoots(startIndex: UInt64, roots: [SubtreeRoot]) async throws
+
+    /// Updates the wallet's view of the blockchain.
+    ///
+    /// This method is used to provide the wallet with information about the state of the blockchain,
+    /// and detect any previously scanned data that needs to be re-validated before proceeding with
+    /// scanning. It should be called at wallet startup prior to calling `suggestScanRanges`
+    /// in order to provide the wallet with the information it needs to correctly prioritize scanning
+    /// operations.
+    func updateChainTip(height: Int32) async throws
+
+    /// Returns the height to which the wallet has been fully scanned.
+    ///
+    /// This is the height for which the wallet has fully trial-decrypted this and all
+    /// preceding blocks beginning with the wallet's birthday height.
+    func fullyScannedHeight() async throws -> BlockHeight?
+
+    /// Returns the maximum height that the wallet has scanned.
+    ///
+    /// If the wallet is fully synced, this will be equivalent to `fullyScannedHeight`;
+    /// otherwise the maximal scanned height is likely to be greater than the fully scanned
+    /// height due to the fact that out-of-order scanning can leave gaps.
+    func maxScannedHeight() async throws -> BlockHeight?
+
+    /// Returns the scan progress derived from the current wallet state.
+    func getScanProgress() async throws -> ScanProgress?
+
+    /// Returns a list of suggested scan ranges based upon the current wallet state.
+    ///
+    /// This method should only be used in cases where the `CompactBlock` data that will be
+    /// made available to `scanBlocks` for the requested block ranges includes note
+    /// commitment tree size information for each block; or else the scan is likely to fail if
+    /// notes belonging to the wallet are detected.
+    func suggestScanRanges() async throws -> [ScanRange]
+
     /// Scans new blocks added to the cache for any transactions received by the tracked
-    /// accounts.
-    /// This function pays attention only to cached blocks with heights greater than the
-    /// highest scanned block in `db_data`. Cached blocks with lower heights are not verified
-    /// against previously-scanned blocks. In particular, this function **assumes** that the
-    /// caller is handling rollbacks.
+    /// accounts, while checking that they form a valid chan.
+    ///
+    /// This function is built on the core assumption that the information provided in the
+    /// block cache is more likely to be accurate than the previously-scanned information.
+    /// This follows from the design (and trust) assumption that the `lightwalletd` server
+    /// provides accurate block information as of the time it was requested.
+    ///
+    /// This function **assumes** that the caller is handling rollbacks.
+    ///
     /// For brand-new light client databases, this function starts scanning from the Sapling
     /// activation height. This height can be fast-forwarded to a more recent block by calling
     /// [`initBlocksTable`] before this function.
+    ///
     /// Scanned blocks are required to be height-sequential. If a block is missing from the
     /// cache, an error will be signalled.
     ///
-    /// - parameter limit: scan up to limit blocks. pass 0 to set no limit.
+    /// - parameter fromHeight: scan starting from the given height.
+    /// - parameter limit: scan up to limit blocks.
     /// - Throws: `rustScanBlocks` if rust layer returns error.
-    func scanBlocks(limit: UInt32) async throws
+    func scanBlocks(fromHeight: Int32, limit: UInt32) async throws
 
     /// Upserts a UTXO into the data db database
     /// - parameter txid: the txid bytes for the UTXO
@@ -229,7 +223,7 @@ protocol ZcashRustBackendWelding {
         usk: UnifiedSpendingKey,
         memo: MemoBytes?,
         shieldingThreshold: Zatoshi
-    ) async throws -> Int64
+    ) async throws -> Data
 
     /// Gets the consensus branch id for the given height
     /// - Parameter height: the height you what to know the branch id for
@@ -252,5 +246,5 @@ protocol ZcashRustBackendWelding {
     /// this directory  is expected to contain a `/blocks` sub-directory with the blocks stored in the convened filename
     /// format `{height}-{hash}-block`. This directory has must be granted both write and read permissions.
     /// - Returns `BlockHeight` of the latest cached block or `.empty` if no blocks are stored.
-    func latestCachedBlockHeight() async -> BlockHeight
+    func latestCachedBlockHeight() async throws -> BlockHeight
 }

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