react-native-zcash 0.6.13 → 0.7.0

package/ios/ZCashLightClientKit/Synchronizer/ClosureSDKSynchronizer.swift

@@ -70,6 +70,46 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
         }
     }
 
+    public func proposeTransfer(
+        accountIndex: Int,
+        recipient: Recipient,
+        amount: Zatoshi,
+        memo: Memo?,
+        completion: @escaping (Result<Proposal, Error>) -> Void
+    ) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.proposeTransfer(accountIndex: accountIndex, recipient: recipient, amount: amount, memo: memo)
+        }
+    }
+
+    public func proposeShielding(
+        accountIndex: Int,
+        shieldingThreshold: Zatoshi,
+        memo: Memo,
+        transparentReceiver: TransparentAddress? = nil,
+        completion: @escaping (Result<Proposal?, Error>) -> Void
+    ) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.proposeShielding(
+                accountIndex: accountIndex,
+                shieldingThreshold: shieldingThreshold,
+                memo: memo,
+                transparentReceiver: transparentReceiver
+            )
+        }
+    }
+
+    public func createProposedTransactions(
+        proposal: Proposal,
+        spendingKey: UnifiedSpendingKey,
+        completion: @escaping (Result<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>) -> Void
+    ) {
+        AsyncToClosureGateway.executeThrowingAction(completion) {
+            try await self.synchronizer.createProposedTransactions(proposal: proposal, spendingKey: spendingKey)
+        }
+    }
+
+    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
     public func sendToAddress(
         spendingKey: UnifiedSpendingKey,
         zatoshi: Zatoshi,
@@ -82,6 +122,7 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
         }
     }
 
+    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
     public func shieldFunds(
         spendingKey: UnifiedSpendingKey,
         memo: Memo,
@@ -147,21 +188,9 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
         }
     }
 
-    public func getTransparentBalance(accountIndex: Int, completion: @escaping (Result<WalletBalance, Error>) -> Void) {
-        AsyncToClosureGateway.executeThrowingAction(completion) {
-            try await self.synchronizer.getTransparentBalance(accountIndex: accountIndex)
-        }
-    }
-
-    public func getShieldedBalance(accountIndex: Int, completion: @escaping (Result<Zatoshi, Error>) -> Void) {
-        AsyncToClosureGateway.executeThrowingAction(completion) {
-            try await self.synchronizer.getShieldedBalance(accountIndex: accountIndex)
-        }
-    }
-
-    public func getShieldedVerifiedBalance(accountIndex: Int, completion: @escaping (Result<Zatoshi, Error>) -> Void) {
+    public func getAccountBalance(accountIndex: Int, completion: @escaping (Result<AccountBalance?, Error>) -> Void) {
         AsyncToClosureGateway.executeThrowingAction(completion) {
-            try await self.synchronizer.getShieldedVerifiedBalance(accountIndex: accountIndex)
+            try await self.synchronizer.getAccountBalance(accountIndex: accountIndex)
         }
     }
 

package/ios/ZCashLightClientKit/Synchronizer/CombineSDKSynchronizer.swift

@@ -69,6 +69,55 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
         }
     }
 
+    public func proposeTransfer(
+        accountIndex: Int,
+        recipient: Recipient,
+        amount: Zatoshi,
+        memo: Memo?
+    ) -> SinglePublisher<Proposal, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.proposeTransfer(accountIndex: accountIndex, recipient: recipient, amount: amount, memo: memo)
+        }
+    }
+
+     public func proposefulfillingPaymentURI(
+        _ uri: String,
+        accountIndex: Int
+    ) -> SinglePublisher<Proposal, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.proposefulfillingPaymentURI(
+                uri,
+                accountIndex: accountIndex
+            )
+        }
+    }
+
+    public func proposeShielding(
+        accountIndex: Int,
+        shieldingThreshold: Zatoshi,
+        memo: Memo,
+        transparentReceiver: TransparentAddress? = nil
+    ) -> SinglePublisher<Proposal?, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.proposeShielding(
+                accountIndex: accountIndex,
+                shieldingThreshold: shieldingThreshold,
+                memo: memo,
+                transparentReceiver: transparentReceiver
+            )
+        }
+    }
+
+    public func createProposedTransactions(
+        proposal: Proposal,
+        spendingKey: UnifiedSpendingKey
+    ) -> SinglePublisher<AsyncThrowingStream<TransactionSubmitResult, Error>, Error> {
+        AsyncToCombineGateway.executeThrowingAction() {
+            try await self.synchronizer.createProposedTransactions(proposal: proposal, spendingKey: spendingKey)
+        }
+    }
+
+    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
     public func sendToAddress(
         spendingKey: UnifiedSpendingKey,
         zatoshi: Zatoshi,
@@ -80,6 +129,7 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
         }
     }
 
+    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
     public func shieldFunds(
         spendingKey: UnifiedSpendingKey,
         memo: Memo,
@@ -140,21 +190,9 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
         }
     }
 
-    public func getTransparentBalance(accountIndex: Int) -> SinglePublisher<WalletBalance, Error> {
-        AsyncToCombineGateway.executeThrowingAction() {
-            try await self.synchronizer.getTransparentBalance(accountIndex: accountIndex)
-        }
-    }
-
-    public func getShieldedBalance(accountIndex: Int = 0) -> SinglePublisher<Zatoshi, Error> {
-        AsyncToCombineGateway.executeThrowingAction() {
-            try await synchronizer.getShieldedBalance(accountIndex: accountIndex)
-        }
-    }
-
-    public func getShieldedVerifiedBalance(accountIndex: Int = 0) -> SinglePublisher<Zatoshi, Error> {
+    public func getAccountBalance(accountIndex: Int) -> SinglePublisher<AccountBalance?, Error> {
         AsyncToCombineGateway.executeThrowingAction() {
-            try await synchronizer.getShieldedVerifiedBalance(accountIndex: accountIndex)
+            try await self.synchronizer.getAccountBalance(accountIndex: accountIndex)
         }
     }
 

package/ios/ZCashLightClientKit/Synchronizer/Dependencies.swift

@@ -17,6 +17,10 @@ enum Dependencies {
         loggingPolicy: Initializer.LoggingPolicy = .default(.debug),
         enableBackendTracing: Bool = false
     ) {
+        container.register(type: CheckpointSource.self, isSingleton: true) { _ in
+            CheckpointSourceFactory.fromBundle(for: networkType)
+        }
+
         container.register(type: Logger.self, isSingleton: true) { _ in
             let logger: Logger
             switch loggingPolicy {
@@ -32,7 +36,7 @@ enum Dependencies {
         }
 
         container.register(type: ZcashRustBackendWelding.self, isSingleton: true) { _ in
-            return ZcashRustBackend(
+            ZcashRustBackend(
                 dbData: urls.dataDbURL,
                 fsBlockDbRoot: urls.fsBlockDbRoot,
                 spendParamsPath: urls.spendParamsURL,
@@ -43,7 +47,7 @@ enum Dependencies {
         }
 
         container.register(type: LightWalletService.self, isSingleton: true) { _ in
-            return LightWalletGRPCService(endpoint: endpoint)
+            LightWalletGRPCService(endpoint: endpoint)
         }
 
         container.register(type: TransactionRepository.self, isSingleton: true) { _ in
@@ -75,7 +79,7 @@ enum Dependencies {
         }
 
         container.register(type: SDKMetrics.self, isSingleton: true) { _ in
-            SDKMetrics()
+            SDKMetricsImpl()
         }
 
         container.register(type: LatestBlocksDataProvider.self, isSingleton: true) { di in
@@ -96,8 +100,7 @@ enum Dependencies {
     
     static func setupCompactBlockProcessor(
         in container: DIContainer,
-        config: CompactBlockProcessor.Configuration,
-        accountRepository: AccountRepository
+        config: CompactBlockProcessor.Configuration
     ) {
         container.register(type: BlockDownloader.self, isSingleton: true) { di in
             let service = di.resolve(LightWalletService.self)
@@ -116,6 +119,7 @@ enum Dependencies {
         }
 
         container.register(type: BlockScanner.self, isSingleton: true) { di in
+            let service = di.resolve(LightWalletService.self)
             let rustBackend = di.resolve(ZcashRustBackendWelding.self)
             let transactionRepository = di.resolve(TransactionRepository.self)
             let metrics = di.resolve(SDKMetrics.self)
@@ -129,6 +133,7 @@ enum Dependencies {
             return BlockScannerImpl(
                 config: blockScannerConfig,
                 rustBackend: rustBackend,
+                service: service,
                 transactionRepository: transactionRepository,
                 metrics: metrics,
                 logger: logger
@@ -159,7 +164,6 @@ enum Dependencies {
             let logger = di.resolve(Logger.self)
             
             return UTXOFetcherImpl(
-                accountRepository: accountRepository,
                 blockDownloaderService: blockDownloaderService,
                 config: utxoFetcherConfig,
                 rustBackend: rustBackend,

package/ios/ZCashLightClientKit/Synchronizer/SDKSynchronizer.swift

@@ -12,6 +12,7 @@ import Combine
 /// Synchronizer implementation for UIKit and iOS 13+
 // swiftlint:disable type_body_length
 public class SDKSynchronizer: Synchronizer {
+    
     public var alias: ZcashSynchronizerAlias { initializer.alias }
 
     private lazy var streamsUpdateQueue = { DispatchQueue(label: "streamsUpdateQueue_\(initializer.alias.description)") }()
@@ -22,7 +23,7 @@ public class SDKSynchronizer: Synchronizer {
     private let eventSubject = PassthroughSubject<SynchronizerEvent, Never>()
     public var eventStream: AnyPublisher<SynchronizerEvent, Never> { eventSubject.eraseToAnyPublisher() }
 
-    public let metrics: SDKMetrics
+    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.
@@ -39,13 +40,11 @@ public class SDKSynchronizer: Synchronizer {
     public let network: ZcashNetwork
     private let transactionEncoder: TransactionEncoder
     private let transactionRepository: TransactionRepository
-    private let utxoRepository: UnspentTransactionOutputRepository
 
     private let syncSessionIDGenerator: SyncSessionIDGenerator
     private let syncSession: SyncSession
     private let syncSessionTicker: SessionTicker
-    private var syncStartDate: Date?
-    let latestBlocksDataProvider: LatestBlocksDataProvider
+    var latestBlocksDataProvider: LatestBlocksDataProvider
 
     /// Creates an SDKSynchronizer instance
     /// - Parameter initializer: a wallet Initializer object
@@ -55,7 +54,6 @@ public class SDKSynchronizer: Synchronizer {
             initializer: initializer,
             transactionEncoder: WalletTransactionEncoder(initializer: initializer),
             transactionRepository: initializer.transactionRepository,
-            utxoRepository: UTXORepositoryBuilder.build(initializer: initializer),
             blockProcessor: CompactBlockProcessor(
                 initializer: initializer,
                 walletBirthdayProvider: { initializer.walletBirthday }
@@ -69,7 +67,6 @@ public class SDKSynchronizer: Synchronizer {
         initializer: Initializer,
         transactionEncoder: TransactionEncoder,
         transactionRepository: TransactionRepository,
-        utxoRepository: UnspentTransactionOutputRepository,
         blockProcessor: CompactBlockProcessor,
         syncSessionTicker: SessionTicker
     ) {
@@ -78,7 +75,6 @@ public class SDKSynchronizer: Synchronizer {
         self.initializer = initializer
         self.transactionEncoder = transactionEncoder
         self.transactionRepository = transactionRepository
-        self.utxoRepository = utxoRepository
         self.blockProcessor = blockProcessor
         self.network = initializer.network
         self.metrics = initializer.container.resolve(SDKMetrics.self)
@@ -104,6 +100,7 @@ public class SDKSynchronizer: Synchronizer {
 
     func updateStatus(_ newValue: InternalSyncStatus, updateExternalStatus: Bool = true) async {
         let oldValue = await underlyingStatus.update(newValue)
+        logger.info("Synchronizer's status updated from \(oldValue) to \(newValue)")
         await notify(oldStatus: oldValue, newStatus: newValue, updateExternalStatus: updateExternalStatus)
     }
 
@@ -136,8 +133,6 @@ public class SDKSynchronizer: Synchronizer {
             throw error
         }
 
-        try await utxoRepository.initialise()
-
         if case .seedRequired = try await self.initializer.initialize(with: seed, walletBirthday: walletBirthday, for: walletMode) {
             return .seedRequired
         }
@@ -164,8 +159,8 @@ public class SDKSynchronizer: Synchronizer {
             await blockProcessor.start(retry: retry)
 
         case .stopped, .synced, .disconnected, .error:
-            await updateStatus(.syncing(0))
-            syncStartDate = Date()
+            let syncProgress = (try? await initializer.rustBackend.getWalletSummary()?.scanProgress?.progress()) ?? 0
+            await updateStatus(.syncing(syncProgress))
             await blockProcessor.start(retry: retry)
         }
     }
@@ -244,13 +239,6 @@ public class SDKSynchronizer: Synchronizer {
         await latestBlocksDataProvider.updateScannedData()
 
         await updateStatus(.synced)
-
-        if let syncStartDate {
-            metrics.pushSyncReport(
-                start: syncStartDate,
-                end: Date()
-            )
-        }
     }
 
     private func foundTransactions(transactions: [ZcashTransaction.Overview], in range: CompactBlockRange) {
@@ -272,6 +260,99 @@ public class SDKSynchronizer: Synchronizer {
 
     // MARK: Synchronizer methods
 
+    public func proposeTransfer(accountIndex: Int, recipient: Recipient, amount: Zatoshi, memo: Memo?) async throws -> Proposal {
+        try throwIfUnprepared()
+
+        if case Recipient.transparent = recipient, memo != nil {
+            throw ZcashError.synchronizerSendMemoToTransparentAddress
+        }
+
+        let proposal = try await transactionEncoder.proposeTransfer(
+            accountIndex: accountIndex,
+            recipient: recipient.stringEncoded,
+            amount: amount,
+            memoBytes: memo?.asMemoBytes()
+        )
+
+        return proposal
+    }
+
+    public func proposeShielding(
+        accountIndex: Int,
+        shieldingThreshold: Zatoshi,
+        memo: Memo,
+        transparentReceiver: TransparentAddress? = nil
+    ) async throws -> Proposal? {
+        try throwIfUnprepared()
+
+        return try await transactionEncoder.proposeShielding(
+            accountIndex: accountIndex,
+            shieldingThreshold: shieldingThreshold,
+            memoBytes: memo.asMemoBytes(),
+            transparentReceiver: transparentReceiver?.stringEncoded
+        )
+    }
+
+    public func proposefulfillingPaymentURI(
+        _ uri: String,
+        accountIndex: Int
+    ) async throws -> Proposal {
+        do {
+            try throwIfUnprepared()
+            return try await transactionEncoder.proposeFulfillingPaymentFromURI(
+               uri,
+               accountIndex: accountIndex
+           )
+        } catch ZcashError.rustCreateToAddress(let error) {
+            throw ZcashError.rustProposeTransferFromURI(error)
+        } catch {
+            throw error
+        }
+    }
+
+    public func createProposedTransactions(
+        proposal: Proposal,
+        spendingKey: UnifiedSpendingKey
+    ) async throws -> AsyncThrowingStream<TransactionSubmitResult, Error> {
+        try throwIfUnprepared()
+
+        try await SaplingParameterDownloader.downloadParamsIfnotPresent(
+            spendURL: initializer.spendParamsURL,
+            spendSourceURL: initializer.saplingParamsSourceURL.spendParamFileURL,
+            outputURL: initializer.outputParamsURL,
+            outputSourceURL: initializer.saplingParamsSourceURL.outputParamFileURL,
+            logger: logger
+        )
+
+        let transactions = try await transactionEncoder.createProposedTransactions(
+            proposal: proposal,
+            spendingKey: spendingKey
+        )
+        var iterator = transactions.makeIterator()
+        var submitFailed = false
+
+        return AsyncThrowingStream() {
+            guard let transaction = iterator.next() else { return nil }
+
+            if submitFailed {
+                return .notAttempted(txId: transaction.rawID)
+            } else {
+                let encodedTransaction = try transaction.encodedTransaction()
+
+                do {
+                    try await self.transactionEncoder.submit(transaction: encodedTransaction)
+                    return TransactionSubmitResult.success(txId: transaction.rawID)
+                } catch ZcashError.serviceSubmitFailed(let error) {
+                    submitFailed = true
+                    return TransactionSubmitResult.grpcFailure(txId: transaction.rawID, error: error)
+                } catch TransactionEncoderError.submitError(let code, let message) {
+                    submitFailed = true
+                    return TransactionSubmitResult.submitFailure(txId: transaction.rawID, code: code, description: message)
+                }
+            }
+        }
+    }
+
     public func sendToAddress(
         spendingKey: UnifiedSpendingKey,
         zatoshi: Zatoshi,
@@ -309,20 +390,31 @@ public class SDKSynchronizer: Synchronizer {
 
         // let's see if there are funds to shield
         let accountIndex = Int(spendingKey.account)
-        let tBalance = try await self.getTransparentBalance(accountIndex: accountIndex)
+
+        guard let tBalance = try await self.getAccountBalance(accountIndex: accountIndex)?.unshielded else {
+            throw ZcashError.synchronizerSpendingKeyDoesNotBelongToTheWallet
+        }
 
         // 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 {
+        guard tBalance >= self.network.constants.defaultFee() else {
             throw ZcashError.synchronizerShieldFundsInsuficientTransparentFunds
         }
 
-        let transaction = try await transactionEncoder.createShieldingTransaction(
-            spendingKey: spendingKey,
+        guard let proposal = try await transactionEncoder.proposeShielding(
+            accountIndex: Int(spendingKey.account),
             shieldingThreshold: shieldingThreshold,
             memoBytes: memo.asMemoBytes(),
-            from: Int(spendingKey.account)
+            transparentReceiver: nil
+        ) else { throw ZcashError.synchronizerShieldFundsInsuficientTransparentFunds }
+
+        let transactions = try await transactionEncoder.createProposedTransactions(
+            proposal: proposal,
+            spendingKey: spendingKey
         )
 
+        assert(transactions.count == 1, "Rust backend doesn't produce multiple transactions yet")
+        let transaction = transactions[0]
+
         let encodedTx = try transaction.encodedTransaction()
 
         try await transactionEncoder.submit(transaction: encodedTx)
@@ -343,14 +435,21 @@ public class SDKSynchronizer: Synchronizer {
                 throw ZcashError.synchronizerSendMemoToTransparentAddress
             }
 
-            let transaction = try await transactionEncoder.createTransaction(
-                spendingKey: spendingKey,
-                zatoshi: zatoshi,
-                to: recipient.stringEncoded,
-                memoBytes: memo?.asMemoBytes(),
-                from: Int(spendingKey.account)
+            let proposal = try await transactionEncoder.proposeTransfer(
+                accountIndex: Int(spendingKey.account),
+                recipient: recipient.stringEncoded,
+                amount: zatoshi,
+                memoBytes: memo?.asMemoBytes()
             )
 
+            let transactions = try await transactionEncoder.createProposedTransactions(
+                proposal: proposal,
+                spendingKey: spendingKey
+            )
+
+            assert(transactions.count == 1, "Rust backend doesn't produce multiple transactions yet")
+            let transaction = transactions[0]
+
             let encodedTransaction = try transaction.encodedTransaction()
 
             try await transactionEncoder.submit(transaction: encodedTransaction)
@@ -397,40 +496,13 @@ public class SDKSynchronizer: Synchronizer {
         try await blockProcessor.latestHeight()
     }
 
-    public func latestUTXOs(address: String) async throws -> [UnspentTransactionOutputEntity] {
-        try throwIfUnprepared()
-
-        guard initializer.isValidTransparentAddress(address) else {
-            throw ZcashError.synchronizerLatestUTXOsInvalidTAddress
-        }
-        
-        let stream = initializer.lightWalletService.fetchUTXOs(for: address, height: network.constants.saplingActivationHeight)
-        
-        // swiftlint:disable:next array_constructor
-        var utxos: [UnspentTransactionOutputEntity] = []
-        for try await transactionEntity in stream {
-            utxos.append(transactionEntity)
-        }
-        try await self.utxoRepository.clearAll(address: address)
-        try await self.utxoRepository.store(utxos: utxos)
-        return utxos
-    }
-
     public func refreshUTXOs(address: TransparentAddress, from height: BlockHeight) async throws -> RefreshedUTXOs {
         try throwIfUnprepared()
         return try await blockProcessor.refreshUTXOs(tAddress: address, startHeight: height)
     }
 
-    public func getShieldedBalance(accountIndex: Int = 0) async throws -> Zatoshi {
-        let balance = try await initializer.rustBackend.getBalance(account: Int32(accountIndex))
-
-        return Zatoshi(balance)
-    }
-
-    public func getShieldedVerifiedBalance(accountIndex: Int = 0) async throws -> Zatoshi {
-        let balance = try await initializer.rustBackend.getVerifiedBalance(account: Int32(accountIndex))
-
-        return Zatoshi(balance)
+    public func getAccountBalance(accountIndex: Int = 0) async throws -> AccountBalance? {
+        try await initializer.rustBackend.getWalletSummary()?.accountBalances[UInt32(accountIndex)]
     }
 
     public func getUnifiedAddress(accountIndex: Int) async throws -> UnifiedAddress {
@@ -445,11 +517,6 @@ public class SDKSynchronizer: Synchronizer {
         try await blockProcessor.getTransparentAddress(accountIndex: accountIndex)
     }
 
-    /// Returns the last stored transparent balance
-    public func getTransparentBalance(accountIndex: Int) async throws -> WalletBalance {
-        try await blockProcessor.getTransparentBalance(accountIndex: accountIndex)
-    }
-
     // MARK: Rewind
 
     public func rewind(_ policy: RewindPolicy) -> AnyPublisher<Void, Error> {
@@ -536,17 +603,100 @@ public class SDKSynchronizer: Synchronizer {
 
         return subject.eraseToAnyPublisher()
     }
-    
+
+    public func isSeedRelevantToAnyDerivedAccount(seed: [UInt8]) async throws -> Bool {
+        try await initializer.rustBackend.isSeedRelevantToAnyDerivedAccount(seed: seed)
+    }
+
+    // MARK: Server switch
+
+    public func switchTo(endpoint: LightWalletEndpoint) async throws {
+        // Stop synchronization
+        let status = await self.status
+        if status != .stopped && status != .disconnected {
+            await blockProcessor.stop()
+        }
+
+        // Validation of the server is first because any custom endpoint can be passed here
+        // Extra instance of the service is created with lower timeout ofr a single call
+        initializer.container.register(type: LightWalletService.self, isSingleton: true) { _ in
+            LightWalletGRPCService(
+                host: endpoint.host,
+                port: endpoint.port,
+                secure: endpoint.secure,
+                singleCallTimeout: 5000,
+                streamingCallTimeout: endpoint.streamingCallTimeoutInMillis
+            )
+        }
+
+        let validateSever = ValidateServerAction(
+            container: initializer.container,
+            configProvider: CompactBlockProcessor.ConfigProvider(config: await blockProcessor.config)
+        )
+ 
+        do {
+            _ = try await validateSever.run(with: ActionContextImpl(state: .idle)) { _ in }
+        } catch {
+            throw ZcashError.synchronizerServerSwitch
+        }
+        
+        // The `ValidateServerAction` confirmed the server is ok and we can continue
+        // final instance of the service will be instantiated and propagated to the all parties
+
+        // SWITCH TO NEW ENDPOINT
+        
+        // LightWalletService dependency update
+        initializer.container.register(type: LightWalletService.self, isSingleton: true) { _ in
+            LightWalletGRPCService(endpoint: endpoint)
+        }
+
+        // DEPENDENCIES
+
+        // BlockDownloaderService dependency update
+        initializer.container.register(type: BlockDownloaderService.self, isSingleton: true) { di in
+            let service = di.resolve(LightWalletService.self)
+            let storage = di.resolve(CompactBlockRepository.self)
+
+            return BlockDownloaderServiceImpl(service: service, storage: storage)
+        }
+
+        // LatestBlocksDataProvider dependency update
+        initializer.container.register(type: LatestBlocksDataProvider.self, isSingleton: true) { di in
+            let service = di.resolve(LightWalletService.self)
+            let rustBackend = di.resolve(ZcashRustBackendWelding.self)
+
+            return LatestBlocksDataProviderImpl(service: service, rustBackend: rustBackend)
+        }
+        
+        // CompactBlockProcessor dependency update
+        Dependencies.setupCompactBlockProcessor(
+            in: initializer.container,
+            config: await blockProcessor.config
+        )
+        
+        // INITIALIZER
+        initializer.lightWalletService = initializer.container.resolve(LightWalletService.self)
+        initializer.blockDownloaderService = initializer.container.resolve(BlockDownloaderService.self)
+        initializer.endpoint = endpoint
+
+        // SELF
+        self.latestBlocksDataProvider = initializer.container.resolve(LatestBlocksDataProvider.self)
+        
+        // COMPACT BLOCK PROCESSOR
+        await blockProcessor.updateService(initializer.container)
+        
+        // Start synchronization
+        if status != .unprepared {
+            try await start(retry: true)
+        }
+    }
+
     // MARK: notify state
 
     private func snapshotState(status: InternalSyncStatus) async -> SynchronizerState {
-        return await SynchronizerState(
+        await SynchronizerState(
             syncSessionID: syncSession.value,
-            shieldedBalance: WalletBalance(
-                verified: (try? await getShieldedVerifiedBalance()) ?? .zero,
-                total: (try? await getShieldedBalance()) ?? .zero
-            ),
-            transparentBalance: (try? await blockProcessor.getTransparentBalance(accountIndex: 0)) ?? .zero,
+            accountBalance: try? await getAccountBalance(),
             internalSyncStatus: status,
             latestBlockHeight: latestBlocksDataProvider.latestBlockHeight
         )