react-native-zcash 0.4.2 → 0.6.0

package/ios/RNZcash.swift

@@ -8,17 +8,21 @@ var SynchronizerMap = [String: WalletSynchronizer]()
 struct ConfirmedTx {
   var minedHeight: Int
   var toAddress: String?
+  var raw: String?
   var rawTransactionId: String
   var blockTimeInSeconds: Int
   var value: String
+  var fee: String?
   var memos: Array<String>?
   var dictionary: [String: Any?] {
     return [
       "minedHeight": minedHeight,
       "toAddress": toAddress,
+      "raw": raw,
       "rawTransactionId": rawTransactionId,
       "blockTimeInSeconds": blockTimeInSeconds,
       "value": value,
+      "fee": fee,
       "memos": memos ?? [],
     ]
   }
@@ -42,16 +46,10 @@ struct TotalBalances {
 }
 
 struct ProcessorState {
-  var alias: String
-  var lastDownloadedHeight: Int
-  var lastScannedHeight: Int
   var scanProgress: Int
   var networkBlockHeight: Int
   var dictionary: [String: Any] {
     return [
-      "alias": alias,
-      "lastDownloadedHeight": lastDownloadedHeight,
-      "lastScannedHeight": lastScannedHeight,
       "scanProgress": scanProgress,
       "networkBlockHeight": networkBlockHeight,
     ]
@@ -83,7 +81,7 @@ class RNZcash: RCTEventEmitter {
   // Synchronizer
   @objc func initialize(
     _ seed: String, _ birthdayHeight: Int, _ alias: String, _ networkName: String,
-    _ defaultHost: String, _ defaultPort: Int, resolver resolve: @escaping RCTPromiseResolveBlock,
+    _ defaultHost: String, _ defaultPort: Int, _ newWallet: Bool, resolver resolve: @escaping RCTPromiseResolveBlock,
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) {
     Task {
@@ -92,6 +90,7 @@ class RNZcash: RCTEventEmitter {
       let initializer = Initializer(
         cacheDbURL: try! cacheDbURLHelper(alias, network),
         fsBlockDbRoot: try! fsBlockDbRootURLHelper(alias, network),
+        generalStorageURL: try! generalStorageURLHelper(alias, network),
         dataDbURL: try! dataDbURLHelper(alias, network),
         endpoint: endpoint,
         network: network,
@@ -105,12 +104,12 @@ class RNZcash: RCTEventEmitter {
           let wallet = try WalletSynchronizer(
             alias: alias, initializer: initializer, emitter: sendToJs)
           let seedBytes = try Mnemonic.deterministicSeedBytes(from: seed)
-          let viewingKeys = try deriveUnifiedViewingKey(seed, network)
+          let initMode = newWallet ? WalletInitMode.newWallet : WalletInitMode.existingWallet
 
           _ = try await wallet.synchronizer.prepare(
             with: seedBytes,
-            viewingKeys: [viewingKeys],
-            walletBirthday: birthdayHeight
+            walletBirthday: birthdayHeight,
+            for: initMode
           )
           try await wallet.synchronizer.start()
           wallet.subscribe()
@@ -221,7 +220,7 @@ class RNZcash: RCTEventEmitter {
             memo: sdkMemo
           )
 
-          let tx: NSMutableDictionary = ["txId": broadcastTx.rawID.hexEncodedString()]
+          let tx: NSMutableDictionary = ["txId": broadcastTx.rawID.toHexStringTxId()]
           if broadcastTx.raw != nil {
             tx["raw"] = broadcastTx.raw?.hexEncodedString()
           }
@@ -235,97 +234,6 @@ class RNZcash: RCTEventEmitter {
     }
   }
 
-  @objc func getTransactions(
-    _ alias: String, _ first: Int, _ last: Int, resolver resolve: @escaping RCTPromiseResolveBlock,
-    rejecter reject: @escaping RCTPromiseRejectBlock
-  ) {
-    Task {
-      if let wallet = SynchronizerMap[alias] {
-        if !wallet.fullySynced {
-          reject("GetTransactionsError", "Wallet is not synced", genericError)
-          return
-        }
-
-        var out: [NSDictionary] = []
-        do {
-          let txs = try await wallet.synchronizer.allTransactions()
-          let filterTxs = txs.filter {
-            $0.minedHeight != nil && $0.minedHeight! >= first && $0.minedHeight! <= last
-              && $0.blockTime != nil
-          }
-          for tx in filterTxs {
-            var confTx = ConfirmedTx(
-              minedHeight: tx.minedHeight!,
-              rawTransactionId: (tx.rawID.toHexStringTxId()),
-              blockTimeInSeconds: Int(tx.blockTime!),
-              value: String(describing: abs(tx.value.amount))
-            )
-            if tx.isSentTransaction {
-              let recipients = await wallet.synchronizer.getRecipients(for: tx)
-              if recipients.count > 0 {
-                let addresses = recipients.compactMap {
-                  if case let .address(address) = $0 {
-                    return address
-                  } else {
-                    return nil
-                  }
-                }
-                if addresses.count > 0 {
-                  confTx.toAddress = addresses.first!.stringEncoded
-                }
-              }
-            }
-            if tx.memoCount > 0 {
-              let memos = (try? await wallet.synchronizer.getMemos(for: tx)) ?? []
-              let textMemos = memos.compactMap {
-                return $0.toString()
-              }
-              confTx.memos = textMemos
-            }
-            out.append(confTx.nsDictionary)
-          }
-          resolve(out)
-        } catch {
-          reject("GetTransactionsError", "Failed to get transactions", genericError)
-        }
-      } else {
-        reject("GetTransactionsError", "Wallet does not exist", genericError)
-      }
-    }
-  }
-
-  @objc func getBalance(
-    _ alias: String, resolver resolve: @escaping RCTPromiseResolveBlock,
-    rejecter reject: @escaping RCTPromiseRejectBlock
-  ) {
-    Task {
-      if let wallet = SynchronizerMap[alias] {
-        do {
-          let totalShieldedBalance = try await wallet.synchronizer.getShieldedBalance()
-          let availableShieldedBalance = try await wallet.synchronizer.getShieldedVerifiedBalance()
-
-          let transparentWalletBalance = try await wallet.synchronizer.getTransparentBalance(
-            accountIndex: 0)
-          let totalTransparentBalance = transparentWalletBalance.total
-          let availableTransparentBalance = transparentWalletBalance.verified
-
-          let totalAvailable = availableShieldedBalance + availableTransparentBalance
-          let totalTotal = totalShieldedBalance + totalTransparentBalance
-
-          let balance = TotalBalances(
-            availableZatoshi: String(totalAvailable.amount), totalZatoshi: String(totalTotal.amount)
-          )
-          resolve(balance.nsDictionary)
-          return
-        } catch {
-          reject("GetShieldedBalanceError", "Error", error)
-        }
-      } else {
-        reject("GetShieldedBalanceError", "Wallet does not exist", genericError)
-      }
-    }
-  }
-
   @objc func rescan(
     _ alias: String, resolver resolve: @escaping RCTPromiseResolveBlock,
     rejecter reject: @escaping RCTPromiseRejectBlock
@@ -343,6 +251,7 @@ class RNZcash: RCTEventEmitter {
                 wallet.initializeProcessorState()
                 wallet.cancellables.forEach { $0.cancel() }
                 wallet.subscribe()
+                try await wallet.synchronizer.start()
                 resolve(nil)
               case .failure:
                 reject("RescanError", "Failed to rescan wallet", genericError)
@@ -405,7 +314,14 @@ class RNZcash: RCTEventEmitter {
       if let wallet = SynchronizerMap[alias] {
         do {
           let unifiedAddress = try await wallet.synchronizer.getUnifiedAddress(accountIndex: 0)
-          resolve(unifiedAddress.stringEncoded)
+          let saplingAddress = try await wallet.synchronizer.getSaplingAddress(accountIndex: 0)
+          let transparentAddress = try await wallet.synchronizer.getTransparentAddress(accountIndex: 0)
+          let addresses: NSDictionary = [
+            "unifiedAddress": unifiedAddress.stringEncoded,
+            "saplingAddress": saplingAddress.stringEncoded,
+            "transparentAddress": transparentAddress.stringEncoded
+          ]
+          resolve(addresses)
           return
         } catch {
           reject("deriveUnifiedAddress", "Failed to derive unified address", error)
@@ -437,7 +353,7 @@ class RNZcash: RCTEventEmitter {
   }
 
   override func supportedEvents() -> [String] {
-    return ["StatusEvent", "UpdateEvent"]
+    return ["BalanceEvent", "StatusEvent", "TransactionEvent", "UpdateEvent"]
   }
 }
 
@@ -450,6 +366,7 @@ 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
@@ -459,12 +376,10 @@ class WalletSynchronizer: NSObject {
     self.fullySynced = false
     self.restart = false
     self.processorState = ProcessorState(
-      alias: self.alias,
-      lastDownloadedHeight: 0,
-      lastScannedHeight: 0,
       scanProgress: 0,
       networkBlockHeight: 0
     )
+    self.balances = TotalBalances(availableZatoshi: "0", totalZatoshi: "0")
   }
 
   public func subscribe() {
@@ -472,10 +387,25 @@ class WalletSynchronizer: NSObject {
       .throttle(for: .seconds(0.3), scheduler: DispatchQueue.main, latest: true)
       .sink(receiveValue: { [weak self] state in self?.updateSyncStatus(event: state) })
       .store(in: &cancellables)
+    self.synchronizer.stateStream
+      .sink(receiveValue: { [weak self] state in self?.updateProcessorState(event: state) })
+      .store(in: &cancellables)
+    self.synchronizer.eventStream
+      .sink { SynchronizerEvent in
+        switch SynchronizerEvent {
+          case .minedTransaction(let transaction):
+              self.emitTxs(transactions: [transaction])
+          case .foundTransactions(let transactions, _):
+              self.emitTxs(transactions: transactions)
+          default:
+              return
+          }
+      }
+      .store(in: &cancellables)
   }
 
   func updateSyncStatus(event: SynchronizerState) {
-
+    
     if !self.fullySynced {
       switch event.internalSyncStatus {
       case .syncing:
@@ -495,68 +425,104 @@ class WalletSynchronizer: NSObject {
       let data: NSDictionary = ["alias": self.alias, "name": self.status]
       emit("StatusEvent", data)
     }
-
-    updateProcessorState(event: event)
   }
 
   func updateProcessorState(event: SynchronizerState) {
-    let prevLastDownloadedHeight = self.processorState.lastDownloadedHeight
-    let prevScanProgress = self.processorState.scanProgress
-    let prevLastScannedHeight = self.synchronizer.latestState.latestScannedHeight
-    let prevNetworkBlockHeight = self.processorState.lastScannedHeight
-
-    if event.internalSyncStatus != .synced {
-      switch event.internalSyncStatus {
-      case .syncing(let status):
-        // The SDK emits all zero values just before emitting a SYNCED status so we need to ignore these
-        if status.targetHeight == 0 {
-          return
-        }
-        self.processorState.lastDownloadedHeight = status.progressHeight
-        self.processorState.scanProgress = Int(floor(status.progress * 100))
-        self.processorState.lastScannedHeight = status.progressHeight
-        self.processorState.networkBlockHeight = status.targetHeight
-      default:
-        return
-      }
-    } else {
-      self.processorState.lastDownloadedHeight = self.synchronizer.latestState.latestScannedHeight
-      self.processorState.scanProgress = 100
-      self.processorState.lastScannedHeight = self.synchronizer.latestState.latestScannedHeight
-      self.processorState.networkBlockHeight = event.latestBlockHeight
+    var scanProgress = 0
+
+    switch event.internalSyncStatus {
+    case .syncing(let progress):
+      scanProgress = Int(floor(progress * 100))
+    case .synced:
+      scanProgress = 100
+    case .unprepared, .disconnected, .stopped:
+      scanProgress = 0
+    default:
+      return
     }
 
-    if self.processorState.lastDownloadedHeight != prevLastDownloadedHeight
-      || self.processorState.scanProgress != prevScanProgress
-      || self.processorState.lastScannedHeight != prevLastScannedHeight
-      || self.processorState.networkBlockHeight != prevNetworkBlockHeight
-    {
-      emit("UpdateEvent", self.processorState.nsDictionary)
-    }
+    if (scanProgress == self.processorState.scanProgress && event.latestBlockHeight == self.processorState.networkBlockHeight) { return }
+
+    self.processorState = ProcessorState(scanProgress: scanProgress, networkBlockHeight: event.latestBlockHeight)
+    let data: NSDictionary = ["alias": self.alias, "scanProgress": self.processorState.scanProgress, "networkBlockHeight": self.processorState.networkBlockHeight]
+    emit("UpdateEvent", data)
+    updateBalanceState(event: event)
   }
 
   func initializeProcessorState() {
     self.processorState = ProcessorState(
-      alias: self.alias,
-      lastDownloadedHeight: 0,
-      lastScannedHeight: 0,
       scanProgress: 0,
       networkBlockHeight: 0
     )
+    self.balances = TotalBalances(availableZatoshi: "0", totalZatoshi: "0")
   }
-}
 
-func z_hexEncodedString(data: Data) -> String {
-  let hexDigits = Array("0123456789abcdef".utf16)
-  var chars: [unichar] = []
+  func updateBalanceState(event: SynchronizerState) {
+    let transparentBalance = event.transparentBalance
+    let shieldedBalance = event.shieldedBalance
+
+    let availableTransparentBalance = transparentBalance.verified
+    let totalTransparentBalance = transparentBalance.total
+
+    let availableShieldedBalance = shieldedBalance.verified
+    let totalShieldedBalance = shieldedBalance.total
+
+    let availableZatoshi = String((availableShieldedBalance + availableTransparentBalance).amount)
+    let totalZatoshi = String((totalShieldedBalance + totalTransparentBalance).amount)
+
+    if (availableZatoshi == self.balances.availableZatoshi && totalZatoshi == self.balances.totalZatoshi) { return }
 
-  chars.reserveCapacity(2 * data.count)
-  for byte in data {
-    chars.append(hexDigits[Int(byte / 16)])
-    chars.append(hexDigits[Int(byte % 16)])
+    self.balances = TotalBalances(availableZatoshi: availableZatoshi, totalZatoshi: totalZatoshi)
+    let data: NSDictionary = ["alias": self.alias, "availableZatoshi": self.balances.availableZatoshi, "totalZatoshi": self.balances.totalZatoshi]
+    emit("BalanceEvent", data)
   }
 
-  return String(utf16CodeUnits: chars, count: chars.count)
+  func emitTxs(transactions: [ZcashTransaction.Overview]) {
+    Task {
+      var out: [NSDictionary] = []
+      for tx in transactions {
+        if (tx.isExpiredUmined ?? false) { continue }
+        var confTx = ConfirmedTx(
+          minedHeight: tx.minedHeight!,
+          rawTransactionId: (tx.rawID.toHexStringTxId()),
+          blockTimeInSeconds: Int(tx.blockTime!),
+          value: String(describing: abs(tx.value.amount))
+        )
+        if tx.raw != nil {
+          confTx.raw = tx.raw!.hexEncodedString()
+        }
+        if tx.fee != nil {
+          confTx.fee = String(describing: abs(tx.value.amount))
+        }
+        if tx.isSentTransaction {
+          let recipients = await self.synchronizer.getRecipients(for: tx)
+          if recipients.count > 0 {
+            let addresses = recipients.compactMap {
+              if case let .address(address) = $0 {
+                return address
+              } else {
+                return nil
+              }
+            }
+            if addresses.count > 0 {
+              confTx.toAddress = addresses.first!.stringEncoded
+            }
+          }
+        }
+        if tx.memoCount > 0 {
+          let memos = (try? await self.synchronizer.getMemos(for: tx)) ?? []
+          let textMemos = memos.compactMap {
+            return $0.toString()
+          }
+          confTx.memos = textMemos
+        }
+        out.append(confTx.nsDictionary)
+      }
+
+      let data: NSDictionary = ["alias": self.alias, "transactions": NSArray(array: out)]
+      emit("TransactionEvent", data)
+    }
+  }
 }
 
 // Local file helper funcs
@@ -596,3 +562,11 @@ func fsBlockDbRootURLHelper(_ alias: String, _ network: ZcashNetwork) throws ->
       isDirectory: true
     )
 }
+
+func generalStorageURLHelper(_ alias: String, _ network: ZcashNetwork) throws -> URL {
+  try documentsDirectoryHelper()
+    .appendingPathComponent(
+      network.constants.defaultDbNamePrefix + alias + "general_storage",
+      isDirectory: true
+    )
+}

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

@@ -0,0 +1,98 @@
+//
+//  Action.swift
+//  
+//
+//  Created by Michal Fousek on 05.05.2023.
+//
+
+import Foundation
+
+protocol ActionContext {
+    var state: CBPState { get async }
+    var prevState: CBPState? { get async }
+    var syncControlData: SyncControlData { get async }
+    var requestedRewindHeight: BlockHeight? { get async }
+    var processedHeight: BlockHeight { get async }
+    var lastChainTipUpdateTime: TimeInterval { get async }
+    var lastScannedHeight: BlockHeight? { get async }
+    var lastEnhancedHeight: BlockHeight? { get async }
+    
+    func update(state: CBPState) async
+    func update(syncControlData: SyncControlData) async
+    func update(processedHeight: BlockHeight) async
+    func update(lastChainTipUpdateTime: TimeInterval) async
+    func update(lastScannedHeight: BlockHeight) async
+    func update(lastDownloadedHeight: BlockHeight) async
+    func update(lastEnhancedHeight: BlockHeight?) async
+    func update(requestedRewindHeight: BlockHeight) async
+}
+
+actor ActionContextImpl: ActionContext {
+    var state: CBPState
+    var prevState: CBPState?
+    var syncControlData: SyncControlData
+    var requestedRewindHeight: BlockHeight?
+    /// Amount of blocks that have been processed so far
+    var processedHeight: BlockHeight = 0
+    /// Update chain tip must be called repeatadly, this value stores the previous update and help to decide when to call it again
+    var lastChainTipUpdateTime: TimeInterval = 0.0
+    var lastScannedHeight: BlockHeight?
+    var lastDownloadedHeight: BlockHeight?
+    var lastEnhancedHeight: BlockHeight?
+
+    init(state: CBPState) {
+        self.state = state
+        syncControlData = SyncControlData.empty
+    }
+
+    func update(state: CBPState) async {
+        prevState = self.state
+        self.state = state
+    }
+    func update(syncControlData: SyncControlData) async { self.syncControlData = syncControlData }
+    func update(processedHeight: BlockHeight) async { self.processedHeight = processedHeight }
+    func update(lastChainTipUpdateTime: TimeInterval) async { self.lastChainTipUpdateTime = lastChainTipUpdateTime }
+    func update(lastScannedHeight: BlockHeight) async { self.lastScannedHeight = lastScannedHeight }
+    func update(lastDownloadedHeight: BlockHeight) async { self.lastDownloadedHeight = lastDownloadedHeight }
+    func update(lastEnhancedHeight: BlockHeight?) async { self.lastEnhancedHeight = lastEnhancedHeight }
+    func update(requestedRewindHeight: BlockHeight) async { self.requestedRewindHeight = requestedRewindHeight }
+}
+
+enum CBPState: CaseIterable {
+    case idle
+    case migrateLegacyCacheDB
+    case validateServer
+    case updateSubtreeRoots
+    case updateChainTip
+    case processSuggestedScanRanges
+    case rewind
+    case download
+    case scan
+    case clearAlreadyScannedBlocks
+    case enhance
+    case fetchUTXO
+    case handleSaplingParams
+    case clearCache
+    case finished
+    case failed
+    case stopped
+}
+
+protocol Action {
+    /// If this is true and action fails with error then blocks cache is cleared.
+    var removeBlocksCacheWhenFailed: Bool { get }
+
+    // When any action is created it can get `DIContainer` and resolve any depedencies it requires.
+    // Every action uses `context` to get some informartion like download range.
+    //
+    // `didUpdate` is closure that action use to tell CBP that some part of the work is done. For example if download action would like to
+    // update progress on every block downloaded it can use this closure. Also if action doesn't need to update progress on partial work it doesn't
+    // need to use this closure at all.
+    //
+    // Each action updates context accordingly. It should at least set new state. Reason for this is that action can return different states for
+    // different conditions. And action is the thing that knows these conditions.
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext
+
+    // Should be called on each existing action when processor wants to stop. Some actions may do it's own background work.
+    func stop() async
+}

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

@@ -0,0 +1,35 @@
+//
+//  ClearCacheForLastScannedBatch.swift
+//  
+//
+//  Created by Michal Fousek on 08.05.2023.
+//
+
+import Foundation
+
+final class ClearAlreadyScannedBlocksAction {
+    let storage: CompactBlockRepository
+    let transactionRepository: TransactionRepository
+    
+    init(container: DIContainer) {
+        storage = container.resolve(CompactBlockRepository.self)
+        transactionRepository = container.resolve(TransactionRepository.self)
+    }
+}
+
+extension ClearAlreadyScannedBlocksAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        guard let lastScannedHeight = await context.lastScannedHeight else {
+            throw ZcashError.compactBlockProcessorLastScannedHeight
+        }
+        
+        try await storage.clear(upTo: lastScannedHeight)
+
+        await context.update(state: .enhance)
+        return context
+    }
+
+    func stop() async { }
+}

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

@@ -0,0 +1,30 @@
+//
+//  ClearCacheAction.swift
+//  
+//
+//  Created by Michal Fousek on 05.05.2023.
+//
+
+import Foundation
+
+final class ClearCacheAction {
+    let storage: CompactBlockRepository
+
+    init(container: DIContainer) {
+        storage = container.resolve(CompactBlockRepository.self)
+    }
+}
+
+extension ClearCacheAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { false }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        try await storage.clear()
+        
+        await context.update(state: .processSuggestedScanRanges)
+        
+        return context
+    }
+
+    func stop() async { }
+}

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

@@ -0,0 +1,67 @@
+//
+//  DownloadAction.swift
+//  
+//
+//  Created by Michal Fousek on 05.05.2023.
+//
+
+import Foundation
+
+final class DownloadAction {
+    let configProvider: CompactBlockProcessor.ConfigProvider
+    let downloader: BlockDownloader
+    let transactionRepository: TransactionRepository
+    let logger: Logger
+
+    init(container: DIContainer, configProvider: CompactBlockProcessor.ConfigProvider) {
+        self.configProvider = configProvider
+        downloader = container.resolve(BlockDownloader.self)
+        transactionRepository = container.resolve(TransactionRepository.self)
+        logger = container.resolve(Logger.self)
+    }
+
+    private func update(context: ActionContext) async -> ActionContext {
+        await context.update(state: .scan)
+        return context
+    }
+}
+
+extension DownloadAction: Action {
+    var removeBlocksCacheWhenFailed: Bool { true }
+
+    func run(with context: ActionContext, didUpdate: @escaping (CompactBlockProcessor.Event) async -> Void) async throws -> ActionContext {
+        guard let lastScannedHeight = await context.lastScannedHeight else {
+            return await update(context: context)
+        }
+
+        let config = await configProvider.config
+        let latestBlockHeight = await context.syncControlData.latestBlockHeight
+        // This action is executed for each batch (batch size is 100 blocks by default) until all the blocks in whole `downloadRange` are downloaded.
+        // So the right range for this batch must be computed.
+        let batchRangeStart = lastScannedHeight
+        let batchRangeEnd = min(latestBlockHeight, batchRangeStart + config.batchSize)
+
+        guard batchRangeStart <= batchRangeEnd else {
+            return await update(context: context)
+        }
+
+        let batchRange = batchRangeStart...batchRangeEnd
+        let potentialDownloadLimit = batchRange.upperBound + (2 * config.batchSize)
+        let downloadLimit = await context.syncControlData.latestBlockHeight >= potentialDownloadLimit ? potentialDownloadLimit : batchRangeEnd
+
+        logger.debug("Starting download with range: \(batchRangeStart)...\(batchRangeEnd)")
+        
+        await downloader.update(latestDownloadedBlockHeight: batchRangeStart, force: true)
+        try await downloader.setSyncRange(lastScannedHeight...latestBlockHeight, batchSize: config.batchSize)
+        await downloader.setDownloadLimit(downloadLimit)
+        await downloader.startDownload(maxBlockBufferSize: config.downloadBufferSize)
+
+        try await downloader.waitUntilRequestedBlocksAreDownloaded(in: batchRange)
+
+        return await update(context: context)
+    }
+
+    func stop() async {
+        await downloader.stopDownload()
+    }
+}