react-native-zcash 0.5.0 → 0.6.1

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 memos: Array<String>?
+  var fee: String?
+  var memos: [String]?
   var dictionary: [String: Any?] {
     return [
       "minedHeight": minedHeight,
       "toAddress": toAddress,
+      "raw": raw,
       "rawTransactionId": rawTransactionId,
       "blockTimeInSeconds": blockTimeInSeconds,
       "value": value,
+      "fee": fee,
       "memos": memos ?? [],
     ]
   }
@@ -28,12 +32,16 @@ struct ConfirmedTx {
 }
 
 struct TotalBalances {
-  var availableZatoshi: String
-  var totalZatoshi: String
+  var transparentAvailableZatoshi: Zatoshi
+  var transparentTotalZatoshi: Zatoshi
+  var saplingAvailableZatoshi: Zatoshi
+  var saplingTotalZatoshi: Zatoshi
   var dictionary: [String: Any] {
     return [
-      "availableZatoshi": availableZatoshi,
-      "totalZatoshi": totalZatoshi,
+      "transparentAvailableZatoshi": String(transparentAvailableZatoshi.amount),
+      "transparentTotalZatoshi": String(transparentTotalZatoshi.amount),
+      "saplingAvailableZatoshi": String(saplingAvailableZatoshi.amount),
+      "saplingTotalZatoshi": String(saplingTotalZatoshi.amount),
     ]
   }
   var nsDictionary: NSDictionary {
@@ -42,16 +50,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 +85,8 @@ 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 +95,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 +109,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 +225,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,93 +239,39 @@ class RNZcash: RCTEventEmitter {
     }
   }
 
-  @objc func getTransactions(
-    _ alias: String, _ first: Int, _ last: Int, resolver resolve: @escaping RCTPromiseResolveBlock,
+  @objc func shieldFunds(
+    _ alias: String, _ seed: String, _ memo: String, _ threshold: String,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) {
     Task {
       if let wallet = SynchronizerMap[alias] {
         if !wallet.fullySynced {
-          reject("GetTransactionsError", "Wallet is not synced", genericError)
+          reject("shieldFunds", "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 spendingKey = try deriveUnifiedSpendingKey(seed, wallet.synchronizer.network)
+          let sdkMemo = try Memo(string: memo)
+          let shieldingThreshold = Int64(threshold) ?? 10000
 
-          let transparentWalletBalance = try await wallet.synchronizer.getTransparentBalance(
-            accountIndex: 0)
-          let totalTransparentBalance = transparentWalletBalance.total
-          let availableTransparentBalance = transparentWalletBalance.verified
+          let tx = try await wallet.synchronizer.shieldFunds(
+            spendingKey: spendingKey,
+            memo: sdkMemo,
+            shieldingThreshold: Zatoshi(shieldingThreshold)
+          )
 
-          let totalAvailable = availableShieldedBalance + availableTransparentBalance
-          let totalTotal = totalShieldedBalance + totalTransparentBalance
+          var confTx = await wallet.parseTx(tx: tx)
 
-          let balance = TotalBalances(
-            availableZatoshi: String(totalAvailable.amount), totalZatoshi: String(totalTotal.amount)
-          )
-          resolve(balance.nsDictionary)
-          return
+          // Hack: Memos aren't ready to be queried right after broadcast
+          confTx.memos = [memo]
+          resolve(confTx.nsDictionary)
         } catch {
-          reject("GetShieldedBalanceError", "Error", error)
+          reject("shieldFunds", "Failed to shield funds", genericError)
         }
       } else {
-        reject("GetShieldedBalanceError", "Wallet does not exist", genericError)
+        reject("shieldFunds", "Wallet does not exist", genericError)
       }
     }
   }
@@ -343,6 +293,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)
@@ -406,11 +357,12 @@ class RNZcash: RCTEventEmitter {
         do {
           let unifiedAddress = try await wallet.synchronizer.getUnifiedAddress(accountIndex: 0)
           let saplingAddress = try await wallet.synchronizer.getSaplingAddress(accountIndex: 0)
-          let transparentAddress = try await wallet.synchronizer.getTransparentAddress(accountIndex: 0)
+          let transparentAddress = try await wallet.synchronizer.getTransparentAddress(
+            accountIndex: 0)
           let addresses: NSDictionary = [
             "unifiedAddress": unifiedAddress.stringEncoded,
             "saplingAddress": saplingAddress.stringEncoded,
-            "transparentAddress": transparentAddress.stringEncoded
+            "transparentAddress": transparentAddress.stringEncoded,
           ]
           resolve(addresses)
           return
@@ -444,7 +396,7 @@ class RNZcash: RCTEventEmitter {
   }
 
   override func supportedEvents() -> [String] {
-    return ["StatusEvent", "UpdateEvent"]
+    return ["BalanceEvent", "StatusEvent", "TransactionEvent", "UpdateEvent"]
   }
 }
 
@@ -457,6 +409,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
@@ -466,12 +419,14 @@ 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(
+      transparentAvailableZatoshi: Zatoshi(0),
+      transparentTotalZatoshi: Zatoshi(0),
+      saplingAvailableZatoshi: Zatoshi(0),
+      saplingTotalZatoshi: Zatoshi(0))
   }
 
   public func subscribe() {
@@ -479,6 +434,21 @@ 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) {
@@ -502,68 +472,130 @@ 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
+    if scanProgress == self.processorState.scanProgress
+      && event.latestBlockHeight == self.processorState.networkBlockHeight
     {
-      emit("UpdateEvent", self.processorState.nsDictionary)
+      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(
+      transparentAvailableZatoshi: Zatoshi(0),
+      transparentTotalZatoshi: Zatoshi(0),
+      saplingAvailableZatoshi: Zatoshi(0),
+      saplingTotalZatoshi: Zatoshi(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 transparentAvailableZatoshi = transparentBalance.verified
+    let transparentTotalZatoshi = transparentBalance.total
 
-  chars.reserveCapacity(2 * data.count)
-  for byte in data {
-    chars.append(hexDigits[Int(byte / 16)])
-    chars.append(hexDigits[Int(byte % 16)])
+    let saplingAvailableZatoshi = shieldedBalance.verified
+    let saplingTotalZatoshi = shieldedBalance.total
+
+    if transparentAvailableZatoshi == self.balances.transparentAvailableZatoshi
+      && transparentTotalZatoshi == self.balances.transparentTotalZatoshi
+      && saplingAvailableZatoshi == self.balances.saplingAvailableZatoshi
+      && saplingTotalZatoshi == self.balances.saplingTotalZatoshi
+    {
+      return
+    }
+
+    self.balances = TotalBalances(
+      transparentAvailableZatoshi: transparentAvailableZatoshi,
+      transparentTotalZatoshi: transparentTotalZatoshi,
+      saplingAvailableZatoshi: saplingAvailableZatoshi,
+      saplingTotalZatoshi: saplingTotalZatoshi
+    )
+    let data = NSMutableDictionary(dictionary: self.balances.nsDictionary)
+    data["alias"] = self.alias
+    emit("BalanceEvent", data)
+  }
+
+  func parseTx(tx: ZcashTransaction.Overview) async -> ConfirmedTx {
+    var confTx = ConfirmedTx(
+      minedHeight: tx.minedHeight ?? 0,
+      rawTransactionId: (tx.rawID.toHexStringTxId()),
+      blockTimeInSeconds: Int(tx.blockTime ?? 0),
+      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
+    }
+    return confTx
   }
 
-  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 }
+        let confTx = await parseTx(tx: tx)
+        out.append(confTx.nsDictionary)
+      }
+
+      let data: NSDictionary = ["alias": self.alias, "transactions": NSArray(array: out)]
+      emit("TransactionEvent", data)
+    }
+  }
 }
 
 // Local file helper funcs
@@ -603,3 +635,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 { }
+}