react-native-zcash 0.9.12 → 0.10.0

package/ios/RNZcash.swift

@@ -4,7 +4,24 @@ import MnemonicSwift
 import SwiftProtobuf
 import os
 
-var SynchronizerMap = [String: WalletSynchronizer]()
+actor SynchronizerStore {
+  private var map: [String: WalletSynchronizer] = [:]
+
+  func get(_ alias: String) -> WalletSynchronizer? {
+    map[alias]
+  }
+
+  func set(_ wallet: WalletSynchronizer, for alias: String) {
+    map[alias] = wallet
+  }
+
+  func remove(_ alias: String) {
+    map.removeValue(forKey: alias)
+  }
+
+}
+
+let synchronizerStore = SynchronizerStore()
 
 struct ConfirmedTx {
   var minedHeight: Int
@@ -14,6 +31,8 @@ struct ConfirmedTx {
   var blockTimeInSeconds: Int
   var value: String
   var fee: String?
+  var isShielding: Bool
+  var isExpired: Bool
   var memos: [String]?
   var dictionary: [String: Any?] {
     return [
@@ -25,28 +44,8 @@ struct ConfirmedTx {
       "value": value,
       "fee": fee,
       "memos": memos ?? [],
-    ]
-  }
-  var nsDictionary: NSDictionary {
-    return dictionary as NSDictionary
-  }
-}
-
-struct TotalBalances {
-  var transparentAvailableZatoshi: Zatoshi
-  var transparentTotalZatoshi: Zatoshi
-  var saplingAvailableZatoshi: Zatoshi
-  var saplingTotalZatoshi: Zatoshi
-  var orchardAvailableZatoshi: Zatoshi
-  var orchardTotalZatoshi: Zatoshi
-  var dictionary: [String: Any] {
-    return [
-      "transparentAvailableZatoshi": String(transparentAvailableZatoshi.amount),
-      "transparentTotalZatoshi": String(transparentTotalZatoshi.amount),
-      "saplingAvailableZatoshi": String(saplingAvailableZatoshi.amount),
-      "saplingTotalZatoshi": String(saplingTotalZatoshi.amount),
-      "orchardAvailableZatoshi": String(orchardAvailableZatoshi.amount),
-      "orchardTotalZatoshi": String(orchardTotalZatoshi.amount),
+      "isShielding": isShielding,
+      "isExpired": isExpired,
     ]
   }
   var nsDictionary: NSDictionary {
@@ -109,9 +108,11 @@ class RNZcash: RCTEventEmitter {
         spendParamsURL: try! spendParamsURLHelper(alias),
         outputParamsURL: try! outputParamsURLHelper(alias),
         saplingParamsSourceURL: SaplingParamsSourceURL.default,
-        alias: ZcashSynchronizerAlias.custom(alias)
+        alias: ZcashSynchronizerAlias.custom(alias),
+        isTorEnabled: false,
+        isExchangeRateEnabled: false
       )
-      if SynchronizerMap[alias] == nil {
+      if await synchronizerStore.get(alias) == nil {
         do {
           let wallet = try WalletSynchronizer(
             alias: alias, initializer: initializer, emitter: sendToJs)
@@ -121,11 +122,16 @@ class RNZcash: RCTEventEmitter {
           _ = try await wallet.synchronizer.prepare(
             with: seedBytes,
             walletBirthday: birthdayHeight,
-            for: initMode
+            for: initMode,
+            name: alias,
+            keySource: nil
           )
+          let accounts = try await wallet.synchronizer.listAccounts()
+          let accountUUID = accounts.first(where: { $0.name == alias })?.id
+          wallet.accountUUID = accountUUID
           try await wallet.synchronizer.start()
           wallet.subscribe()
-          SynchronizerMap[alias] = wallet
+          await synchronizerStore.set(wallet, for: alias)
           resolve(nil)
         } catch {
           reject("InitializeError", "Synchronizer failed to initialize", error)
@@ -137,45 +143,28 @@ class RNZcash: RCTEventEmitter {
     }
   }
 
-  @objc func start(
+  @objc func stop(
     _ alias: String, resolver resolve: @escaping RCTPromiseResolveBlock,
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) {
     Task {
-      if let wallet = SynchronizerMap[alias] {
-        do {
-          try await wallet.synchronizer.start()
-          wallet.subscribe()
-        } catch {
-          reject("StartError", "Synchronizer failed to start", error)
-        }
+      if let wallet = await synchronizerStore.get(alias) {
+        wallet.synchronizer.stop()
+        wallet.cancellables.forEach { $0.cancel() }
+        await synchronizerStore.remove(alias)
         resolve(nil)
       } else {
-        reject("StartError", "Wallet does not exist", genericError)
+        reject("StopError", "Wallet does not exist", genericError)
       }
     }
   }
 
-  @objc func stop(
-    _ alias: String, resolver resolve: @escaping RCTPromiseResolveBlock,
-    rejecter reject: @escaping RCTPromiseRejectBlock
-  ) {
-    if let wallet = SynchronizerMap[alias] {
-      wallet.synchronizer.stop()
-      wallet.cancellables.forEach { $0.cancel() }
-      SynchronizerMap[alias] = nil
-      resolve(nil)
-    } else {
-      reject("StopError", "Wallet does not exist", genericError)
-    }
-  }
-
   @objc func getLatestNetworkHeight(
     _ alias: String, resolver resolve: @escaping RCTPromiseResolveBlock,
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) {
     Task {
-      if let wallet = SynchronizerMap[alias] {
+      if let wallet = await synchronizerStore.get(alias) {
         do {
           let height = try await wallet.synchronizer.latestHeight()
           resolve(height)
@@ -197,8 +186,8 @@ class RNZcash: RCTEventEmitter {
       do {
         let endpoint = LightWalletEndpoint(address: host, port: port, secure: true)
         let lightwalletd: LightWalletService = LightWalletGRPCService(endpoint: endpoint)
-        let height = try await lightwalletd.latestBlockHeight()
-        lightwalletd.closeConnection()
+        let height = try await lightwalletd.latestBlockHeight(mode: ServiceMode.direct)
+        await lightwalletd.closeConnections()
         resolve(height)
       } catch {
         reject("getLatestNetworkHeightGrpc", "Failed to query blockheight", error)
@@ -212,7 +201,7 @@ class RNZcash: RCTEventEmitter {
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) {
     Task {
-      if let wallet = SynchronizerMap[alias] {
+      if let wallet = await synchronizerStore.get(alias) {
         let amount = Int64(zatoshi)
         if amount == nil {
           reject("ProposeTransferError", "Amount is invalid", genericError)
@@ -224,8 +213,12 @@ class RNZcash: RCTEventEmitter {
           if memo != "" {
             sdkMemo = try Memo(string: memo)
           }
+          guard let accountUUID = wallet.accountUUID else {
+            reject("ProposeTransferError", "Account UUID not found", genericError)
+            return
+          }
           let proposal = try await wallet.synchronizer.proposeTransfer(
-            accountIndex: 0,
+            accountUUID: accountUUID,
             recipient: Recipient(toAddress, network: wallet.synchronizer.network.networkType),
             amount: Zatoshi(amount!),
             memo: sdkMemo
@@ -259,7 +252,7 @@ class RNZcash: RCTEventEmitter {
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) {
     Task {
-      if let wallet = SynchronizerMap[alias] {
+      if let wallet = await synchronizerStore.get(alias) {
         do {
           let spendingKey = try deriveUnifiedSpendingKey(seed, wallet.synchronizer.network)
           let data = Data.init(base64Encoded: proposalBase64)!
@@ -278,7 +271,7 @@ class RNZcash: RCTEventEmitter {
             case .success(let txId):
               lastTxid = txId.toHexStringTxId()
               continue
-            case let .submitFailure(txId: _, code: code, description: description):
+            case .submitFailure(txId: _, let code, let description):
               throw NSError(
                 domain:
                   "transaction failed to submit with code: \(code) - description: \(description)",
@@ -304,7 +297,7 @@ class RNZcash: RCTEventEmitter {
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) {
     Task {
-      if let wallet = SynchronizerMap[alias] {
+      if let wallet = await synchronizerStore.get(alias) {
         if !wallet.fullySynced {
           reject("shieldFunds", "Wallet is not synced", genericError)
           return
@@ -315,17 +308,52 @@ class RNZcash: RCTEventEmitter {
           let sdkMemo = try Memo(string: memo)
           let shieldingThreshold = Int64(threshold) ?? 10000
 
-          let tx = try await wallet.synchronizer.shieldFunds(
-            spendingKey: spendingKey,
-            memo: sdkMemo,
-            shieldingThreshold: Zatoshi(shieldingThreshold)
+          guard let accountUUID = wallet.accountUUID else {
+            reject("shieldFunds", "Account UUID not found", genericError)
+            return
+          }
+
+          guard
+            let proposal = try await wallet.synchronizer.proposeShielding(
+              accountUUID: accountUUID,
+              shieldingThreshold: Zatoshi(shieldingThreshold),
+              memo: sdkMemo
+            )
+          else {
+            throw NSError(
+              domain: "shieldFunds",
+              code: -1,
+              userInfo: [NSLocalizedDescriptionKey: "Proposal was nil"]
+            )
+
+          }
+
+          let stream = try await wallet.synchronizer.createProposedTransactions(
+            proposal: proposal,
+            spendingKey: spendingKey
           )
 
-          var confTx = await wallet.parseTx(tx: tx)
+          if let result = try await stream.first(where: { _ in true }) {
+            switch result {
+            case .success(let txId):
+              resolve(txId.toHexStringTxId())
+              return
 
-          // Hack: Memos aren't ready to be queried right after broadcast
-          confTx.memos = [memo]
-          resolve(confTx.nsDictionary)
+            default:
+              throw NSError(
+                domain: "shieldFunds",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "Failed: \(result)"]
+              )
+            }
+          } else {
+            // Stream ended without producing any result
+            throw NSError(
+              domain: "shieldFunds",
+              code: -1,
+              userInfo: [NSLocalizedDescriptionKey: "No result returned"]
+            )
+          }
         } catch {
           reject("shieldFunds", "Failed to shield funds", genericError)
         }
@@ -340,7 +368,7 @@ class RNZcash: RCTEventEmitter {
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) {
     Task {
-      if let wallet = SynchronizerMap[alias] {
+      if let wallet = await synchronizerStore.get(alias) {
         wallet.synchronizer.rewind(.birthday).sink(
           receiveCompletion: { completion in
             Task {
@@ -353,6 +381,8 @@ class RNZcash: RCTEventEmitter {
                 wallet.cancellables.forEach { $0.cancel() }
                 try await wallet.synchronizer.start()
                 wallet.subscribe()
+                let txs = try await wallet.synchronizer.allTransactions()
+                wallet.emitTxs(transactions: txs)
                 resolve(nil)
               case .failure:
                 reject("RescanError", "Failed to rescan wallet", genericError)
@@ -381,7 +411,8 @@ class RNZcash: RCTEventEmitter {
   {
     let derivationTool = DerivationTool(networkType: network.networkType)
     let seedBytes = try Mnemonic.deterministicSeedBytes(from: seed)
-    let spendingKey = try derivationTool.deriveUnifiedSpendingKey(seed: seedBytes, accountIndex: 0)
+    let spendingKey = try derivationTool.deriveUnifiedSpendingKey(
+      seed: seedBytes, accountIndex: Zip32AccountIndex(0))
     return spendingKey
   }
 
@@ -412,12 +443,18 @@ class RNZcash: RCTEventEmitter {
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) {
     Task {
-      if let wallet = SynchronizerMap[alias] {
+      if let wallet = await synchronizerStore.get(alias) {
         do {
-          let unifiedAddress = try await wallet.synchronizer.getUnifiedAddress(accountIndex: 0)
-          let saplingAddress = try await wallet.synchronizer.getSaplingAddress(accountIndex: 0)
+          guard let accountUUID = wallet.accountUUID else {
+            reject("deriveUnifiedAddress", "Account UUID not found", genericError)
+            return
+          }
+          let unifiedAddress = try await wallet.synchronizer.getUnifiedAddress(
+            accountUUID: accountUUID)
+          let saplingAddress = try await wallet.synchronizer.getSaplingAddress(
+            accountUUID: accountUUID)
           let transparentAddress = try await wallet.synchronizer.getTransparentAddress(
-            accountIndex: 0)
+            accountUUID: accountUUID)
           let addresses: NSDictionary = [
             "unifiedAddress": unifiedAddress.stringEncoded,
             "saplingAddress": saplingAddress.stringEncoded,
@@ -472,6 +509,7 @@ class RNZcash: RCTEventEmitter {
 
 class WalletSynchronizer: NSObject {
   public var alias: String
+  public var accountUUID: AccountUUID?
   public var synchronizer: SDKSynchronizer
   var status: String
   var emit: (String, Any) -> Void
@@ -479,7 +517,6 @@ class WalletSynchronizer: NSObject {
   var restart: Bool
   var processorState: ProcessorState
   var cancellables: [AnyCancellable] = []
-  var balances: TotalBalances
 
   init(alias: String, initializer: Initializer, emitter: @escaping (String, Any) -> Void) throws {
     self.alias = alias
@@ -492,13 +529,6 @@ class WalletSynchronizer: NSObject {
       scanProgress: 0,
       networkBlockHeight: 0
     )
-    self.balances = TotalBalances(
-      transparentAvailableZatoshi: Zatoshi(0),
-      transparentTotalZatoshi: Zatoshi(0),
-      saplingAvailableZatoshi: Zatoshi(0),
-      saplingTotalZatoshi: Zatoshi(0),
-      orchardAvailableZatoshi: Zatoshi(0),
-      orchardTotalZatoshi: Zatoshi(0))
   }
 
   public func subscribe() {
@@ -567,7 +597,7 @@ class WalletSynchronizer: NSObject {
     var scanProgress = 0
 
     switch event.internalSyncStatus {
-    case .syncing(let progress):
+    case .syncing(let progress, _):
       scanProgress = Int(floor(progress * 100))
     case .synced:
       scanProgress = 100
@@ -598,19 +628,22 @@ class WalletSynchronizer: NSObject {
       scanProgress: 0,
       networkBlockHeight: 0
     )
-    self.balances = TotalBalances(
-      transparentAvailableZatoshi: Zatoshi(0),
-      transparentTotalZatoshi: Zatoshi(0),
-      saplingAvailableZatoshi: Zatoshi(0),
-      saplingTotalZatoshi: Zatoshi(0),
-      orchardAvailableZatoshi: Zatoshi(0),
-      orchardTotalZatoshi: Zatoshi(0))
   }
 
   func updateBalanceState(event: SynchronizerState) {
-    let transparentBalance = event.accountBalance?.unshielded ?? Zatoshi(0)
-    let shieldedBalance = event.accountBalance?.saplingBalance ?? PoolBalance.zero
-    let orchardBalance = event.accountBalance?.orchardBalance ?? PoolBalance.zero
+    guard let accountUUID = self.accountUUID else {
+      return
+    }
+
+    // Safely check if the account exists in the balances dictionary
+    guard let accountBalance = event.accountsBalances[accountUUID] else {
+      return
+    }
+
+    // Account exists, safely access the balance properties
+    let transparentBalance = accountBalance.unshielded
+    let shieldedBalance = accountBalance.saplingBalance
+    let orchardBalance = accountBalance.orchardBalance
 
     let transparentAvailableZatoshi = transparentBalance
     let transparentTotalZatoshi = transparentBalance
@@ -621,16 +654,15 @@ class WalletSynchronizer: NSObject {
     let orchardAvailableZatoshi = orchardBalance.spendableValue
     let orchardTotalZatoshi = orchardBalance.total()
 
-    self.balances = TotalBalances(
-      transparentAvailableZatoshi: transparentAvailableZatoshi,
-      transparentTotalZatoshi: transparentTotalZatoshi,
-      saplingAvailableZatoshi: saplingAvailableZatoshi,
-      saplingTotalZatoshi: saplingTotalZatoshi,
-      orchardAvailableZatoshi: orchardAvailableZatoshi,
-      orchardTotalZatoshi: orchardTotalZatoshi
-    )
-    let data = NSMutableDictionary(dictionary: self.balances.nsDictionary)
-    data["alias"] = self.alias
+    let data: NSDictionary = [
+      "alias": self.alias,
+      "transparentAvailableZatoshi": String(transparentAvailableZatoshi.amount),
+      "transparentTotalZatoshi": String(transparentTotalZatoshi.amount),
+      "saplingAvailableZatoshi": String(saplingAvailableZatoshi.amount),
+      "saplingTotalZatoshi": String(saplingTotalZatoshi.amount),
+      "orchardAvailableZatoshi": String(orchardAvailableZatoshi.amount),
+      "orchardTotalZatoshi": String(orchardTotalZatoshi.amount),
+    ]
     emit("BalanceEvent", data)
   }
 
@@ -639,7 +671,9 @@ class WalletSynchronizer: NSObject {
       minedHeight: tx.minedHeight ?? 0,
       rawTransactionId: (tx.rawID.toHexStringTxId()),
       blockTimeInSeconds: Int(tx.blockTime ?? 0),
-      value: String(describing: abs(tx.value.amount))
+      value: String(describing: abs(tx.value.amount)),
+      isShielding: tx.isShielding,
+      isExpired: tx.isExpiredUmined ?? false
     )
     if tx.raw != nil {
       confTx.raw = tx.raw!.hexEncodedString()
@@ -651,7 +685,7 @@ class WalletSynchronizer: NSObject {
       let recipients = await self.synchronizer.getRecipients(for: tx)
       if recipients.count > 0 {
         let addresses = recipients.compactMap {
-          if case let .address(address) = $0 {
+          if case .address(let address) = $0 {
             return address
           } else {
             return nil
@@ -676,7 +710,6 @@ class WalletSynchronizer: NSObject {
     Task {
       var out: [NSDictionary] = []
       for tx in transactions {
-        if tx.isExpiredUmined ?? false { continue }
         let confTx = await parseTx(tx: tx)
         out.append(confTx.nsDictionary)
       }
@@ -687,6 +720,22 @@ class WalletSynchronizer: NSObject {
   }
 }
 
+extension AccountUUID {
+  static func fromAlias(_ alias: String) -> AccountUUID {
+    let bytes = Array(alias.utf8)
+    let folded = foldTo16Bytes(bytes)
+    return AccountUUID(id: folded)
+  }
+}
+
+func foldTo16Bytes(_ bytes: [UInt8]) -> [UInt8] {
+  var out = [UInt8](repeating: 0, count: 16)
+  for (i, b) in bytes.enumerated() {
+    out[i % 16] ^= b
+  }
+  return out
+}
+
 // Local file helper funcs
 func documentsDirectoryHelper() throws -> URL {
   try FileManager.default.url(

package/ios/ZCashLightClientKit/Account/Account.swift

@@ -0,0 +1,48 @@
+//
+//  Account.swift
+//  ZcashLightClientKit
+//
+//  Created by Lukáš Korba on 2024-11-19.
+//
+
+/// A [ZIP 32](https://zips.z.cash/zip-0032) account index.
+///
+/// This index must be paired with a seed, or other context that determines a seed,
+/// in order to identify a ZIP 32 *account*.
+public struct Zip32AccountIndex: Equatable, Codable, Hashable {
+    public let index: UInt32
+    
+    /// - Parameter index: the ZIP 32 account index, which must be less than ``1<<31``.
+    public init(_ index: UInt32) {
+        guard index < (1 << 31) else {
+            fatalError("Account index must be less than 1<<31. Input value is \(index).")
+        }
+        
+        self.index = index
+    }
+}
+
+public struct AccountId: Equatable, Codable, Hashable {
+    public let id: Int
+
+    /// - Parameter id: the local account id, which must be nonnegative.
+    public init(_ id: Int) {
+        guard id >= 0 else {
+            fatalError("Account id must be >= 0. Input value is \(id).")
+        }
+        
+        self.id = id
+    }
+}
+
+public struct AccountUUID: Equatable, Codable, Hashable, Identifiable {
+    public let id: [UInt8]
+    
+    init(id: [UInt8]) {
+        guard id.count == 16 else {
+            fatalError("Account UUID must be 16 bytes long. Input value is \(id).")
+        }
+        
+        self.id = id
+    }
+}

package/ios/ZCashLightClientKit/Account/AccountMetadataKey.swift

@@ -0,0 +1,96 @@
+//
+//  AccountMetadataKey.swift
+//  ZcashLightClientKit
+//
+//  Created by Jack Grigg on 25/02/2025.
+//
+
+import Foundation
+
+
+/// A ZIP 325 Account Metadata Key.
+public class AccountMetadataKey {
+    private let accountMetadataKeyPtr: OpaquePointer
+    private let networkType: NetworkType
+
+    /// Derives a ZIP 325 Account Metadata Key from the given seed.
+    public init(
+        from seed: [UInt8],
+        accountIndex: Zip32AccountIndex,
+        networkType: NetworkType
+    ) throws {
+        let accountMetadataKeyPtr = seed.withUnsafeBufferPointer { seedBufferPtr in
+            return zcashlc_derive_account_metadata_key(
+                seedBufferPtr.baseAddress,
+                UInt(seed.count),
+                LCZip32Index(accountIndex.index),
+                networkType.networkId
+            )
+        }
+
+        guard let accountMetadataKeyPtr else {
+            throw ZcashError.rustDeriveAccountMetadataKey(lastErrorMessage(fallback: "`deriveAccountMetadataKey` failed with unknown error"))
+        }
+
+        self.accountMetadataKeyPtr = accountMetadataKeyPtr
+        self.networkType = networkType
+    }
+
+    deinit {
+        zcashlc_free_account_metadata_key(accountMetadataKeyPtr)
+    }
+
+    /// Derives a metadata key for private use from this ZIP 325 Account Metadata Key.
+    ///
+    /// - Parameter ufvk: the external UFVK for which a metadata key is required, or `null` if the
+    ///   metadata key is "inherent" (for the same account as the Account Metadata Key).
+    /// - Parameter privateUseSubject: a globally unique non-empty sequence of at most 252 bytes
+    ///   that identifies the desired private-use context.
+    ///
+    /// If `ufvk` is null, this function will return a single 32-byte metadata key.
+    ///
+    /// If `ufvk` is non-null, this function will return one metadata key for every FVK item
+    /// contained within the UFVK, in preference order. As UFVKs may in general change over
+    /// time (due to the inclusion of new higher-preference FVK items, or removal of older
+    /// deprecated FVK items), private usage of these keys should always follow preference
+    /// order:
+    /// - For encryption-like private usage, the first key in the array should always be
+    ///   used, and all other keys ignored.
+    /// - For decryption-like private usage, each key in the array should be tried in turn
+    ///   until metadata can be recovered, and then the metadata should be re-encrypted
+    ///   under the first key.
+    public func derivePrivateUseMetadataKey(
+        ufvk: UnifiedFullViewingKey?,
+        privateUseSubject: [UInt8]
+    ) throws -> [Data] {
+        var kSource: [CChar]?
+        if let ufvk {
+            kSource = [CChar](ufvk.stringEncoded.utf8CString)
+        }
+
+        let keysPtr = privateUseSubject.withUnsafeBufferPointer { privateUseSubjectBufferPtr in
+            return zcashlc_derive_private_use_metadata_key(
+                accountMetadataKeyPtr,
+                kSource,
+                privateUseSubjectBufferPtr.baseAddress,
+                UInt(privateUseSubject.count),
+                networkType.networkId
+            )
+        }
+
+        guard let keysPtr else {
+            throw ZcashError.rustDerivePrivateUseMetadataKey(lastErrorMessage(fallback: "`derivePrivateUseMetadataKey` failed with unknown error"))
+        }
+
+        defer { zcashlc_free_txids(keysPtr) }
+
+        var keys: [Data] = []
+
+        for i in (0 ..< Int(keysPtr.pointee.len)) {
+            let txId = FfiTxId(tuple: keysPtr.pointee.ptr.advanced(by: i).pointee)
+            keys.append(Data(txId.array))
+        }
+
+        return keys
+    }
+}

package/ios/ZCashLightClientKit/Block/Actions/ScanAction.swift

@@ -73,13 +73,32 @@ extension ScanAction: Action {
             // Proper solution is handled in
             // TODO: [#1353] Advanced progress reporting, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1353
             if progressReportReducer == 0 {
+                let walletSummary = try? await rustBackend.getWalletSummary()
+                let recoveryProgress = walletSummary?.recoveryProgress
+
                 // report scan progress only if it's available
-                if let scanProgress = try? await rustBackend.getWalletSummary()?.scanProgress {
-                    logger.debug("progress ratio: \(scanProgress.numerator)/\(scanProgress.denominator)")
-                    let progress = try scanProgress.progress()
+                if let scanProgress = walletSummary?.scanProgress {
+                    let composedNumerator = Float(scanProgress.numerator) + Float(recoveryProgress?.numerator ?? 0)
+                    let composedDenominator = Float(scanProgress.denominator) + Float(recoveryProgress?.denominator ?? 0)
+
+                    logger.debug("progress ratio: \(composedNumerator)/\(composedDenominator)")
+                    
+                    let progress: Float
+                    if composedDenominator == 0 {
+                        progress = 1.0
+                    } else {
+                        progress = composedNumerator / composedDenominator
+                    }
+
+                    // this shouldn't happen but if it does, we need to get notified by clients and work on a fix
+                    if progress > 1.0 {
+                        throw ZcashError.rustScanProgressOutOfRange("\(progress)")
+                    }
+
                     logger.debug("progress float: \(progress)")
-                    await didUpdate(.syncProgress(progress))
+                    await didUpdate(.syncProgress(progress, scanProgress.isComplete))
                 }
+
                 progressReportReducer = Constants.reportDelay
             } else {
                 progressReportReducer -= 1

package/ios/ZCashLightClientKit/Block/Actions/UpdateChainTipAction.swift

@@ -13,6 +13,7 @@ final class UpdateChainTipAction {
     var service: LightWalletService
     var latestBlocksDataProvider: LatestBlocksDataProvider
     let logger: Logger
+    let sdkFlags: SDKFlags
     
     init(container: DIContainer) {
         service = container.resolve(LightWalletService.self)
@@ -20,11 +21,13 @@ final class UpdateChainTipAction {
         rustBackend = container.resolve(ZcashRustBackendWelding.self)
         latestBlocksDataProvider = container.resolve(LatestBlocksDataProvider.self)
         logger = container.resolve(Logger.self)
+        sdkFlags = container.resolve(SDKFlags.self)
     }
     
     func updateChainTip(_ context: ActionContext, time: TimeInterval) async throws {
-        let latestBlockHeight = try await service.latestBlockHeight()
-        
+        // called each sync, right after getInfo in ValidateServerAction
+        let latestBlockHeight = try await service.latestBlockHeight(mode: await sdkFlags.ifTor(.defaultTor))
+
         logger.debug("Latest block height is \(latestBlockHeight)")
         try await rustBackend.updateChainTip(height: Int32(latestBlockHeight))
         await context.update(lastChainTipUpdateTime: time)
@@ -43,6 +46,7 @@ extension UpdateChainTipAction: Action {
         if await context.prevState == .updateSubtreeRoots || now - lastChainTipUpdateTime > 600 {
             await downloader.stopDownload()
             try await updateChainTip(context, time: now)
+            await sdkFlags.markChainTipAsUpdated()
             await context.update(state: .clearCache)
         } else if await context.prevState == .txResubmission {
             await context.update(state: .download)