react-native-zcash 0.8.1 → 0.9.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.9.0 (2024-09-25)
+
+- added: Support sending to ZIP-320 TEX addresses
+- changed: Replace `sendToAddress` with `createTransfer`
+- changed: Updated checkpoints
+
 ## 0.8.1 (2024-09-16)
 
 - changed: Updated checkpoints

package/android/build.gradle

@@ -1,7 +1,7 @@
 buildscript {
   def kotlinVersion = rootProject.ext.has('kotlinVersion')
     ? rootProject.ext.get('kotlinVersion')
-    : '1.8.22'
+    : '1.9.23'
 
   repositories {
     mavenCentral()
@@ -49,8 +49,8 @@ dependencies {
 
   implementation 'androidx.appcompat:appcompat:1.6.1'
   implementation 'androidx.paging:paging-runtime-ktx:2.1.2'
-  implementation 'cash.z.ecc.android:zcash-android-sdk:2.1.0'
-  implementation 'cash.z.ecc.android:zcash-android-sdk-incubator:2.1.0'
+  implementation 'cash.z.ecc.android:zcash-android-sdk:2.2.4'
+  implementation 'cash.z.ecc.android:zcash-android-sdk-incubator:2.2.4'
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
 }

package/android/src/main/assets/co.electriccoin.zcash/checkpoint/mainnet/2650000.json

@@ -0,0 +1,8 @@
+{
+  "network": "main",
+  "height": "2650000",
+  "hash": "0000000000b32debcdb364e5fc7988044a4eb29e4f86ed6c97a95f0836e3c37f",
+  "time": 1726602492,
+  "saplingTree": "01e09fe8115a458f1802d1d95ad1cbc4d6737d31ebf4a63f936b62011034dabd31010855462f487eaa137ee9950887b40953765357aff4a9eda4d85d4eccf274c42a1f000001488261fba3b34b7f78d50bc11ce1830c2339813606bb17570d7293128769577101216344eb0f3b3b8bddd4d2b51a36f6bb4fa368125d29dc02cf776797152bd95a00011f360200bebb9acb23f27fd0cb18a95b746d3a07c4df8cf7a843147bd0f9042d0000000001b5c2bb61f0ea5b18cfdeddac25f36c98988ce0705eae6824a3121158a6f6f824010d143acd831f6da07b124b16f4c4e58102caa7517722bb550946c5fa2a245371000000019a730d9d524de40f3fa2a76a8072ff66ef8ce0af24a68a080ef683a9d45aab7301b254e3cfba937bcd40621e1d623a943440b083892546f081aab37058fd1b763f000000013e2598f743726006b8de42476ed56a55a75629a7b82e430c4e7c101a69e9b02a011619f99023a69bb647eab2d2aa1a73c3673c74bb033c3c4930eacda19e6fd93b0000000160272b134ca494b602137d89e528c751c06d3ef4a87a45f33af343c15060cc1e0000000000",
+  "orchardTree": "016c37f7adb67b940b91f05b0d60e1d98c2d4f67c0a766ae367d42a56302ea0416001f015126bbb64a18d6e518922654683434e6aa3c488e1a4e2b35d5ff4bb4d32c310501e8131c28e898b1247a2e28d1691b0854445aecf30e7bd601117fdd36967c893e01c454a4fac32e3c68f16a55476d7e992d7cec2e4af24bc34d7d9c459f58fbe22100000102b7afec099b149198431e309cec4b3f95531b53fa350ff453c0a648276bc1140001cc846293d335bbb212a6c0f54fd45d92f995724d58b9b5fed397dbc55e3bb8030001f783a7a186e453c6d11e88542ed866790b00d4102899da05c57eb0d71fffbc2500000000010c104faa2b1148b1b627090aa939e321b82edcb0ce70aa4eee298997556b4f35000112278dfeae9949f887b70ae81e084f8897a5054627acef3efd01c8b29793d522000160040850b766b126a2b4843fcdfdffa5d5cab3f53bc860a3bef68958b5f066170001cc2dcaa338b312112db04b435a706d63244dd435238f0aa1e9e1598d35470810012dcc4273c8a0ed2337ecf7879380a07e7d427c7f9d82e538002bd1442978402c01daf63debf5b40df902dae98dadc029f281474d190cddecef1b10653248a234150001e2bca6a8d987d668defba89dc082196a922634ed88e065c669e526bb8815ee1b000000000000"
+}

package/android/src/main/java/app/edge/rnzcash/RNZcashModule.kt

@@ -20,6 +20,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
+import java.util.Base64
 
 class RNZcashModule(private val reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
@@ -203,7 +204,7 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
                 }
                 map.putInt("minedHeight", tx.minedHeight?.value?.toInt() ?: 0)
                 map.putInt("blockTimeInSeconds", tx.blockTimeEpochSeconds?.toInt() ?: 0)
-                map.putString("rawTransactionId", tx.rawId.byteArray.toHexReversed())
+                map.putString("rawTransactionId", tx.txIdString())
                 if (tx.raw != null) {
                     map.putString("raw", tx.raw!!.byteArray.toHex())
                 }
@@ -323,6 +324,7 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
                 val map = Arguments.createMap()
                 map.putInt("transactionCount", proposal.transactionCount())
                 map.putString("totalFee", proposal.totalFeeRequired().value.toString())
+                map.putString("proposalBase64", Base64.getEncoder().encodeToString(proposal.toByteArray()))
                 promise.resolve(map)
             } catch (t: Throwable) {
                 promise.reject("Err", t)
@@ -330,12 +332,11 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
         }
     }
 
+    @kotlin.ExperimentalStdlibApi
     @ReactMethod
-    fun sendToAddress(
+    fun createTransfer(
         alias: String,
-        zatoshi: String,
-        toAddress: String,
-        memo: String = "",
+        proposalBase64: String,
         seed: String,
         promise: Promise,
     ) {
@@ -344,18 +345,15 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
             try {
                 val seedPhrase = SeedPhrase.new(seed)
                 val usk = DerivationTool.getInstance().deriveUnifiedSpendingKey(seedPhrase.toByteArray(), wallet.network, Account.DEFAULT)
-                val internalId =
-                    wallet.sendToAddress(
-                        usk,
-                        Zatoshi(zatoshi.toLong()),
-                        toAddress,
-                        memo,
-                    )
-                val tx = wallet.coroutineScope.async { wallet.transactions.first().first() }.await()
-                val map = Arguments.createMap()
-                map.putString("txId", tx.rawId.byteArray.toHexReversed())
-                if (tx.raw != null) map.putString("raw", tx.raw?.byteArray?.toHex())
-                promise.resolve(map)
+                val proposalByteArray = Base64.getDecoder().decode(proposalBase64)
+                val proposal = Proposal.fromByteArray(proposalByteArray)
+
+                val txs =
+                    wallet.coroutineScope.async {
+                        wallet.createProposedTransactions(proposal, usk).take(proposal.transactionCount()).toList()
+                    }.await()
+                val txid = txs[txs.lastIndex].txIdString() // The last transfer is the most relevant to the user
+                promise.resolve(txid)
             } catch (t: Throwable) {
                 promise.reject("Err", t)
             }
@@ -473,14 +471,6 @@ class RNZcashModule(private val reactContext: ReactApplicationContext) :
             .emit(eventName, args)
     }
 
-    private fun ByteArray.toHexReversed(): String {
-        val sb = StringBuilder(size * 2)
-        var i = size - 1
-        while (i >= 0)
-            sb.append(String.format("%02x", this[i--]))
-        return sb.toString()
-    }
-
     data class Balances(
         val transparentBalance: Zatoshi?,
         val saplingBalances: WalletBalance?,

package/ios/RNZcash.m

@@ -44,11 +44,9 @@ resolver:(RCTPromiseResolveBlock)resolve
 rejecter:(RCTPromiseRejectBlock)reject
 )
 
-RCT_EXTERN_METHOD(sendToAddress:(NSString *)alias
-:(NSString *)zatoshi
-:(NSString *)toAddress
-:(NSString *)memo
-:(NSString *)spendingKey
+RCT_EXTERN_METHOD(createTransfer:(NSString *)alias
+:(NSString *)proposalBase64
+:(NSString *)seed
 resolver:(RCTPromiseResolveBlock)resolve
 rejecter:(RCTPromiseRejectBlock)reject
 )

package/ios/RNZcash.swift

@@ -1,6 +1,7 @@
 import Combine
 import Foundation
 import MnemonicSwift
+import SwiftProtobuf
 import os
 
 var SynchronizerMap = [String: WalletSynchronizer]()
@@ -102,6 +103,7 @@ class RNZcash: RCTEventEmitter {
         fsBlockDbRoot: try! fsBlockDbRootURLHelper(alias, network),
         generalStorageURL: try! generalStorageURLHelper(alias, network),
         dataDbURL: try! dataDbURLHelper(alias, network),
+        torDirURL: try! torDirURLHelper(alias, network),
         endpoint: endpoint,
         network: network,
         spendParamsURL: try! spendParamsURLHelper(alias),
@@ -229,7 +231,10 @@ class RNZcash: RCTEventEmitter {
             memo: sdkMemo
           )
 
+          let proposalBase64 = try proposal.inner.serializedData().base64EncodedString()
+
           let out: NSMutableDictionary = [
+            "proposalBase64": proposalBase64,
             "transactionCount": proposal.transactionCount(),
             "totalFee": String(proposal.totalFeeRequired().amount),
           ]
@@ -248,42 +253,47 @@ class RNZcash: RCTEventEmitter {
     }
   }
 
-  @objc func sendToAddress(
-    _ alias: String, _ zatoshi: String, _ toAddress: String, _ memo: String, _ seed: String,
+  @objc func createTransfer(
+    _ alias: String, _ proposalBase64: String, _ seed: String,
     resolver resolve: @escaping RCTPromiseResolveBlock,
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) {
     Task {
       if let wallet = SynchronizerMap[alias] {
-        let amount = Int64(zatoshi)
-        if amount == nil {
-          reject("SpendToAddressError", "Amount is invalid", genericError)
-          return
-        }
-
         do {
           let spendingKey = try deriveUnifiedSpendingKey(seed, wallet.synchronizer.network)
-          var sdkMemo: Memo? = nil
-          if memo != "" {
-            sdkMemo = try Memo(string: memo)
-          }
-          let broadcastTx = try await wallet.synchronizer.sendToAddress(
-            spendingKey: spendingKey,
-            zatoshi: Zatoshi(amount!),
-            toAddress: Recipient(toAddress, network: wallet.synchronizer.network.networkType),
-            memo: sdkMemo
+          let data = Data.init(base64Encoded: proposalBase64)!
+          let ffiProposal = try FfiProposal(serializedData: data)
+          let proposal = Proposal(inner: ffiProposal)
+
+          let transactions = try await wallet.synchronizer.createProposedTransactions(
+            proposal: proposal, spendingKey: spendingKey
           )
 
-          let tx: NSMutableDictionary = ["txId": broadcastTx.rawID.toHexStringTxId()]
-          if broadcastTx.raw != nil {
-            tx["raw"] = broadcastTx.raw?.hexEncodedString()
+          var lastTxid = ""  // The last transfer is the most relevant to the user
+          for try await tx in transactions {
+            switch tx {
+            case .grpcFailure(_, let error):
+              throw error
+            case .success(let txId):
+              lastTxid = txId.toHexStringTxId()
+              continue
+            case let .submitFailure(txId: _, code: code, description: description):
+              throw NSError(
+                domain:
+                  "transaction failed to submit with code: \(code) - description: \(description)",
+                code: 0)
+            case .notAttempted(_):
+              throw NSError(domain: "transaction not attempted", code: 0)
+            }
           }
-          resolve(tx)
+
+          resolve(lastTxid)
         } catch {
-          reject("SpendToAddressError", "Failed to spend", error)
+          reject("createTransfer", "Failed to spend", error)
         }
       } else {
-        reject("SpendToAddressError", "Wallet does not exist", genericError)
+        reject("createTransfer", "Wallet does not exist", genericError)
       }
     }
   }
@@ -432,6 +442,7 @@ class RNZcash: RCTEventEmitter {
     if derivationTool.isValidUnifiedAddress(address)
       || derivationTool.isValidSaplingAddress(address)
       || derivationTool.isValidTransparentAddress(address)
+      || derivationTool.isValidTexAddress(address)
     {
       resolve(true)
     } else {
@@ -698,6 +709,14 @@ func dataDbURLHelper(_ alias: String, _ network: ZcashNetwork) throws -> URL {
     )
 }
 
+func torDirURLHelper(_ alias: String, _ network: ZcashNetwork) throws -> URL {
+  try documentsDirectoryHelper()
+    .appendingPathComponent(
+      network.constants.defaultDbNamePrefix + alias + ZcashSDK.defaultTorDirName,
+      isDirectory: true
+    )
+}
+
 func spendParamsURLHelper(_ alias: String) throws -> URL {
   try documentsDirectoryHelper().appendingPathComponent(alias + "sapling-spend.params")
 }

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

@@ -73,6 +73,7 @@ enum CBPState: CaseIterable {
     case fetchUTXO
     case handleSaplingParams
     case clearCache
+    case txResubmission
     case finished
     case failed
     case stopped

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

@@ -28,7 +28,7 @@ final class EnhanceAction {
         if lastScannedHeight >= latestBlockHeight {
             await context.update(state: .clearCache)
         } else {
-            await context.update(state: .updateChainTip)
+            await context.update(state: .txResubmission)
         }
 
         return context

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

@@ -59,7 +59,7 @@ extension ProcessSuggestedScanRangesAction: Action {
 
             await context.update(state: .download)
         } else {
-            await context.update(state: .finished)
+            await context.update(state: .txResubmission)
         }
         
         return context

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

@@ -98,7 +98,7 @@ extension ScanAction: Action {
         return await update(context: context)
     }
 
-    func stop() async { 
+    func stop() async {
         progressReportReducer = 0
     }
 }

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

@@ -0,0 +1,75 @@
+//
+//  TxResubmissionAction.swift
+//
+//
+//  Created by Lukas Korba on 06-17-2024.
+//
+
+import Foundation
+
+final class TxResubmissionAction {
+    private enum Constants {
+        static let thresholdToTrigger = TimeInterval(300.0)
+    }
+    
+    var latestResolvedTime: TimeInterval = 0
+    let transactionRepository: TransactionRepository
+    let transactionEncoder: TransactionEncoder
+    let logger: Logger
+
+    init(container: DIContainer) {
+        transactionRepository = container.resolve(TransactionRepository.self)
+        transactionEncoder = container.resolve(TransactionEncoder.self)
+        logger = container.resolve(Logger.self)
+    }
+}
+
+extension TxResubmissionAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { true }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        let latestBlockHeight = await context.syncControlData.latestBlockHeight
+        
+        // find all candidates for the resubmission
+        do {
+            logger.info("TxResubmissionAction check started at \(latestBlockHeight) height.")
+            let transactions = try await transactionRepository.findForResubmission(upTo: latestBlockHeight)
+
+            // no candidates, update the time and continue with the next action
+            if transactions.isEmpty {
+                latestResolvedTime = Date().timeIntervalSince1970
+            } else {
+                let now = Date().timeIntervalSince1970
+                let diff = now - latestResolvedTime
+                
+                // the last time resubmission was triggered is more than 5 minutes ago so try again
+                if diff > Constants.thresholdToTrigger {
+                    // resubmission
+                    do {
+                        for transaction in transactions {
+                            logger.info("TxResubmissionAction trying to resubmit transaction \(transaction.rawID.toHexStringTxId()).")
+                            let encodedTransaction = try transaction.encodedTransaction()
+                            
+                            try await transactionEncoder.submit(transaction: encodedTransaction)
+                        }
+                    } catch {
+                        logger.error("TxResubmissionAction failed to resubmit candidates.")
+                    }
+                    
+                    latestResolvedTime = Date().timeIntervalSince1970
+                }
+            }
+        } catch {
+            logger.error("TxResubmissionAction failed to find candidates.")
+        }
+        
+        if await context.prevState == .enhance {
+            await context.update(state: .updateChainTip)
+        } else {
+            await context.update(state: .finished)
+        }
+        return context
+    }
+
+    func stop() async { }
+}

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

@@ -44,7 +44,7 @@ extension UpdateChainTipAction: Action {
             await downloader.stopDownload()
             try await updateChainTip(context, time: now)
             await context.update(state: .clearCache)
-        } else if await context.prevState == .enhance {
+        } else if await context.prevState == .txResubmission {
             await context.update(state: .download)
         }
         

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

@@ -30,7 +30,7 @@ extension UpdateSubtreeRootsAction: Action {
         
         logger.debug("Attempt to get subtree roots, this may fail because lightwalletd may not support Spend before Sync.")
         let stream = service.getSubtreeRoots(request)
-        
+
         var saplingRoots: [SubtreeRoot] = []
         
         do {
@@ -39,6 +39,8 @@ extension UpdateSubtreeRootsAction: Action {
             }
         } catch ZcashError.serviceSubtreeRootsStreamFailed(LightWalletServiceError.timeOut) {
             throw ZcashError.serviceSubtreeRootsStreamFailed(LightWalletServiceError.timeOut)
+        } catch {
+            await context.update(state: .updateChainTip)
         }
 
         logger.debug("Sapling tree has \(saplingRoots.count) subtrees")

package/ios/ZCashLightClientKit/Block/CompactBlockProcessor.swift

@@ -56,6 +56,7 @@ actor CompactBlockProcessor {
         let saplingParamsSourceURL: SaplingParamsSourceURL
         let fsBlockCacheRoot: URL
         let dataDb: URL
+        let torDir: URL
         let spendParamsURL: URL
         let outputParamsURL: URL
         let enhanceBatchSize: Int
@@ -79,6 +80,7 @@ actor CompactBlockProcessor {
             cacheDbURL: URL? = nil,
             fsBlockCacheRoot: URL,
             dataDb: URL,
+            torDir: URL,
             spendParamsURL: URL,
             outputParamsURL: URL,
             saplingParamsSourceURL: SaplingParamsSourceURL,
@@ -94,6 +96,7 @@ actor CompactBlockProcessor {
             self.alias = alias
             self.fsBlockCacheRoot = fsBlockCacheRoot
             self.dataDb = dataDb
+            self.torDir = torDir
             self.spendParamsURL = spendParamsURL
             self.outputParamsURL = outputParamsURL
             self.saplingParamsSourceURL = saplingParamsSourceURL
@@ -112,6 +115,7 @@ actor CompactBlockProcessor {
             alias: ZcashSynchronizerAlias,
             fsBlockCacheRoot: URL,
             dataDb: URL,
+            torDir: URL,
             spendParamsURL: URL,
             outputParamsURL: URL,
             saplingParamsSourceURL: SaplingParamsSourceURL,
@@ -126,6 +130,7 @@ actor CompactBlockProcessor {
             self.alias = alias
             self.fsBlockCacheRoot = fsBlockCacheRoot
             self.dataDb = dataDb
+            self.torDir = torDir
             self.spendParamsURL = spendParamsURL
             self.outputParamsURL = outputParamsURL
             self.saplingParamsSourceURL = saplingParamsSourceURL
@@ -151,6 +156,7 @@ actor CompactBlockProcessor {
                 alias: initializer.alias,
                 fsBlockCacheRoot: initializer.fsBlockDbRoot,
                 dataDb: initializer.dataDbURL,
+                torDir: initializer.torDirURL,
                 spendParamsURL: initializer.spendParamsURL,
                 outputParamsURL: initializer.outputParamsURL,
                 saplingParamsSourceURL: initializer.saplingParamsSourceURL,
@@ -228,6 +234,8 @@ actor CompactBlockProcessor {
                 action = SaplingParamsAction(container: container)
             case .clearCache:
                 action = ClearCacheAction(container: container)
+            case .txResubmission:
+                action = TxResubmissionAction(container: container)
             case .finished, .failed, .stopped, .idle:
                 return nil
             }
@@ -284,6 +292,10 @@ extension CompactBlockProcessor {
     func latestHeight() async throws -> BlockHeight {
         try await blockDownloaderService.latestBlockHeight()
     }
+    
+    func consensusBranchIdFor(_ height: Int32) -> Int32? {
+        try? rustBackend.consensusBranchIdFor(height: height)
+    }
 }
 
 // MARK: - Rewind
@@ -667,6 +679,8 @@ extension CompactBlockProcessor {
             break
         case .stopped:
             break
+        case .txResubmission:
+            break
         }
     }
 

package/ios/ZCashLightClientKit/Block/Download/BlockDownloaderService.swift

@@ -43,7 +43,7 @@ protocol BlockDownloaderService {
     Gets the transaction for the Id given
     - Parameter txId: Data representing the transaction Id
     */
-    func fetchTransaction(txId: Data) async throws -> ZcashTransaction.Fetched
+    func fetchTransaction(txId: Data) async throws -> (tx: ZcashTransaction.Fetched?, status: TransactionStatus)
 
     func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>
 
@@ -111,7 +111,7 @@ extension BlockDownloaderServiceImpl: BlockDownloaderService {
         try await self.storage.latestHeight()
     }
     
-    func fetchTransaction(txId: Data) async throws -> ZcashTransaction.Fetched {
+    func fetchTransaction(txId: Data) async throws -> (tx: ZcashTransaction.Fetched?, status: TransactionStatus) {
         try await lightwalletService.fetchTransaction(txId: txId)
     }
 }

package/ios/ZCashLightClientKit/Block/Enhance/BlockEnhancer.swift

@@ -60,24 +60,8 @@ struct BlockEnhancerImpl {
     let rustBackend: ZcashRustBackendWelding
     let transactionRepository: TransactionRepository
     let metrics: SDKMetrics
+    let service: LightWalletService
     let logger: Logger
-
-    private func enhance(transaction: ZcashTransaction.Overview) async throws -> ZcashTransaction.Overview {
-        logger.debug("Zoom.... Enhance... Tx: \(transaction.rawID.toHexStringTxId())")
-
-        let fetchedTransaction = try await blockDownloaderService.fetchTransaction(txId: transaction.rawID)
-
-        let transactionID = fetchedTransaction.rawID.toHexStringTxId()
-        let block = String(describing: transaction.minedHeight)
-        logger.debug("Decrypting and storing transaction id: \(transactionID) block: \(block)")
-
-        try await rustBackend.decryptAndStoreTransaction(
-            txBytes: fetchedTransaction.raw.bytes,
-            minedHeight: Int32(fetchedTransaction.minedHeight)
-        )
-
-        return try await transactionRepository.find(rawID: fetchedTransaction.rawID)
-    }
 }
 
 extension BlockEnhancerImpl: BlockEnhancer {
@@ -91,54 +75,75 @@ extension BlockEnhancerImpl: BlockEnhancer {
         
         // fetch transactions
         do {
-            let startTime = Date()
-            let transactions = try await transactionRepository.find(in: range, limit: Int.max, kind: .all)
+            let transactionDataRequests = try await rustBackend.transactionDataRequests()
 
-            guard !transactions.isEmpty else {
-                logger.debug("no transactions detected on range: \(range.lowerBound)...\(range.upperBound)")
-                logger.sync("No transactions detected on range: \(range.lowerBound)...\(range.upperBound)")
+            guard !transactionDataRequests.isEmpty else {
+                logger.debug("No transaction data requests detected.")
+                logger.sync("No transaction data requests detected.")
                 return nil
             }
 
-            let chainTipHeight = try await blockDownloaderService.latestBlockHeight()
-
-            let newlyMinedLowerBound = chainTipHeight - ZcashSDK.expiryOffset
-
-            let newlyMinedRange = newlyMinedLowerBound...chainTipHeight
-
-            for index in 0 ..< transactions.count {
-                let transaction = transactions[index]
+            for index in 0 ..< transactionDataRequests.count {
+                let transactionDataRequest = transactionDataRequests[index]
                 var retry = true
-                
+
                 while retry && retries < maxRetries {
                     try Task.checkCancellation()
                     do {
-                        let confirmedTx = try await enhance(transaction: transaction)
-                        retry = false
-                        
-                        let progress = EnhancementProgress(
-                            totalTransactions: transactions.count,
-                            enhancedTransactions: index + 1,
-                            lastFoundTransaction: confirmedTx,
-                            range: range,
-                            newlyMined: confirmedTx.isSentTransaction && newlyMinedRange.contains(confirmedTx.minedHeight ?? 0)
-                        )
-
-                        await didEnhance(progress)
+                        switch transactionDataRequest {
+                        case .getStatus(let txId):
+                            let response = try await blockDownloaderService.fetchTransaction(txId: txId.data)
+                            retry = false
+
+                            if let fetchedTransaction = response.tx {
+                                try await rustBackend.setTransactionStatus(txId: fetchedTransaction.rawID, status: response.status)
+                            }
+                            
+                        case .enhancement(let txId):
+                            let response = try await blockDownloaderService.fetchTransaction(txId: txId.data)
+                            retry = false
+
+                            if response.status == .txidNotRecognized {
+                                try await rustBackend.setTransactionStatus(txId: txId.data, status: .txidNotRecognized)
+                            } else if let fetchedTransaction = response.tx {
+                                try await rustBackend.decryptAndStoreTransaction(
+                                    txBytes: fetchedTransaction.raw.bytes,
+                                    minedHeight: fetchedTransaction.minedHeight
+                                )
+                            }
+
+                        case .spendsFromAddress(let sfa):
+                            guard let blockRangeEnd = sfa.blockRangeEnd else {
+                                logger.error("spendsFromAddress \(sfa) is missing blockRangeEnd, ignoring the request.")
+                                continue
+                            }
+                            
+                            var filter = TransparentAddressBlockFilter()
+                            filter.address = sfa.address
+                            filter.range = BlockRange(startHeight: Int(sfa.blockRangeStart), endHeight: Int(blockRangeEnd - 1))
+
+                            let stream = service.getTaddressTxids(filter)
+
+                            for try await rawTransaction in stream {
+                                let minedHeight = (rawTransaction.height == 0 || rawTransaction.height > UInt32.max) 
+                                ? nil : UInt32(rawTransaction.height)
+
+                                try await rustBackend.decryptAndStoreTransaction(
+                                    txBytes: rawTransaction.data.bytes,
+                                    minedHeight: minedHeight
+                                )
+                            }
+                            retry = false
+                        }
                     } catch {
                         retries += 1
-                        logger.error("could not enhance txId \(transaction.rawID.toHexStringTxId()) - Error: \(error)")
+                        logger.error("could not enhance transactionDataRequest \(transactionDataRequest) - Error: \(error)")
                         if retries > maxRetries {
                             throw error
                         }
                     }
                 }
             }
-            
-            let endTime = Date()
-            let logMsg = "Enhanced \(transactions.count) transaction(s) in \(endTime.timeIntervalSince1970 - startTime.timeIntervalSince1970) for range \(range.lowerBound)...\(range.upperBound)"
-            logger.sync(logMsg)
-            metrics.actionDetail(logMsg, for: .enhance)
         } catch {
             logger.error("error enhancing transactions! \(error)")
             throw error

package/ios/ZCashLightClientKit/Checkpoint/BundleCheckpointSource.swift

@@ -14,12 +14,7 @@ struct BundleCheckpointSource: CheckpointSource {
     
     init(network: NetworkType) {
         self.network = network
-        self.saplingActivation = switch network {
-        case .mainnet:
-            Checkpoint.mainnetMin
-        case .testnet:
-            Checkpoint.testnetMin
-        }
+        self.saplingActivation = if network == .mainnet { Checkpoint.mainnetMin } else { Checkpoint.testnetMin }
     }
 
     func latestKnownCheckpoint() -> Checkpoint {

package/ios/ZCashLightClientKit/Checkpoint/CheckpointSourceFactory.swift

@@ -7,7 +7,7 @@
 
 import Foundation
 
-struct CheckpointSourceFactory {
+enum CheckpointSourceFactory {
     static func fromBundle(for network: NetworkType) -> CheckpointSource {
         BundleCheckpointSource(network: network)
     }