react-native-zcash 0.6.13 → 0.7.0

package/ios/ZCashLightClientKit/Block/CompactBlockProcessor.swift

@@ -28,18 +28,18 @@ actor CompactBlockProcessor {
     private let configProvider: ConfigProvider
     private var afterSyncHooksManager = AfterSyncHooksManager()
 
-    private let accountRepository: AccountRepository
-    let blockDownloaderService: BlockDownloaderService
-    private let latestBlocksDataProvider: LatestBlocksDataProvider
+    var blockDownloaderService: BlockDownloaderService
+    private var latestBlocksDataProvider: LatestBlocksDataProvider
     private let logger: Logger
     private let metrics: SDKMetrics
     private let rustBackend: ZcashRustBackendWelding
-    let service: LightWalletService
+    var service: LightWalletService
     let storage: CompactBlockRepository
     private let transactionRepository: TransactionRepository
     private let fileManager: ZcashFileManager
 
     private var retryAttempts: Int = 0
+    private var serviceFailureRetryAttempts: Int = 0
     private var backoffTimer: Timer?
     private var consecutiveChainValidationErrors: Int = 0
     
@@ -141,20 +141,6 @@ actor CompactBlockProcessor {
         }
     }
 
-    /// Initializes a CompactBlockProcessor instance
-    /// - Parameters:
-    ///  - service: concrete implementation of `LightWalletService` protocol
-    ///  - storage: concrete implementation of `CompactBlockRepository` protocol
-    ///  - backend: a class that complies to `ZcashRustBackendWelding`
-    ///  - config: `Configuration` struct for this processor
-    init(container: DIContainer, config: Configuration) {
-        self.init(
-            container: container,
-            config: config,
-            accountRepository: AccountRepositoryBuilder.build(dataDbURL: config.dataDb, readOnly: true, logger: container.resolve(Logger.self))
-        )
-    }
-
     /// Initializes a CompactBlockProcessor instance from an Initialized object
     /// - Parameters:
     ///     - initializer: an instance that complies to CompactBlockDownloading protocol
@@ -170,20 +156,23 @@ actor CompactBlockProcessor {
                 saplingParamsSourceURL: initializer.saplingParamsSourceURL,
                 walletBirthdayProvider: walletBirthdayProvider,
                 network: initializer.network
-            ),
-            accountRepository: initializer.accountRepository
+            )
         )
     }
 
+    /// Initializes a CompactBlockProcessor instance
+    /// - Parameters:
+    ///  - service: concrete implementation of `LightWalletService` protocol
+    ///  - storage: concrete implementation of `CompactBlockRepository` protocol
+    ///  - backend: a class that complies to `ZcashRustBackendWelding`
+    ///  - config: `Configuration` struct for this processor
     init(
         container: DIContainer,
-        config: Configuration,
-        accountRepository: AccountRepository
+        config: Configuration
     ) {
         Dependencies.setupCompactBlockProcessor(
             in: container,
-            config: config,
-            accountRepository: accountRepository
+            config: config
         )
 
         let configProvider = ConfigProvider(config: config)
@@ -199,7 +188,6 @@ actor CompactBlockProcessor {
         self.storage = container.resolve(CompactBlockRepository.self)
         self.config = config
         self.transactionRepository = container.resolve(TransactionRepository.self)
-        self.accountRepository = accountRepository
         self.fileManager = container.resolve(ZcashFileManager.self)
         self.configProvider = configProvider
     }
@@ -263,6 +251,7 @@ extension CompactBlockProcessor {
     func start(retry: Bool = false) async {
         if retry {
             self.retryAttempts = 0
+            self.serviceFailureRetryAttempts = 0
             self.backoffTimer?.invalidate()
             self.backoffTimer = nil
         }
@@ -289,6 +278,7 @@ extension CompactBlockProcessor {
         self.backoffTimer = nil
         await stopAllActions()
         retryAttempts = 0
+        serviceFailureRetryAttempts = 0
     }
 
     func latestHeight() async throws -> BlockHeight {
@@ -396,6 +386,8 @@ extension CompactBlockProcessor {
 
             try await rewindDownloadBlockAction(to: nil)
 
+            await latestBlocksDataProvider.reset()
+            
             await context.completion(nil)
         } catch {
             await context.completion(error)
@@ -409,6 +401,52 @@ extension CompactBlockProcessor {
     }
 }
 
+// MARK: - Switch server
+
+extension CompactBlockProcessor {
+    func updateService(_ container: DIContainer) {
+        // LightWalletGRPCService
+        let updatedLWDService = container.resolve(LightWalletService.self)
+        
+        (actions[.processSuggestedScanRanges] as? ProcessSuggestedScanRangesAction)?.service = updatedLWDService
+        (actions[.updateChainTip] as? UpdateChainTipAction)?.service = updatedLWDService
+        (actions[.updateSubtreeRoots] as? UpdateSubtreeRootsAction)?.service = updatedLWDService
+        (actions[.validateServer] as? ValidateServerAction)?.service = updatedLWDService
+        self.service = updatedLWDService
+        
+        // BlockDownloaderService
+        let updatedDownloaderService = container.resolve(BlockDownloaderService.self)
+
+        (actions[.rewind] as? RewindAction)?.downloaderService = updatedDownloaderService
+        self.blockDownloaderService = updatedDownloaderService
+        
+        // LatestBlocksDataProvider
+        let updatedLBDProvider = container.resolve(LatestBlocksDataProvider.self)
+
+        (actions[.scan] as? ScanAction)?.latestBlocksDataProvider = updatedLBDProvider
+        (actions[.updateChainTip] as? UpdateChainTipAction)?.latestBlocksDataProvider = updatedLBDProvider
+        self.latestBlocksDataProvider = updatedLBDProvider
+        
+        // BlockDownloader
+        let updatedBlockDownloader = container.resolve(BlockDownloader.self)
+
+        (actions[.download] as? DownloadAction)?.downloader = updatedBlockDownloader
+        (actions[.updateChainTip] as? UpdateChainTipAction)?.downloader = updatedBlockDownloader
+        (actions[.rewind] as? RewindAction)?.downloader = updatedBlockDownloader
+        self.blockDownloaderService = updatedDownloaderService
+        
+        // BlockEnhancer
+        let updatedEnhancer = container.resolve(BlockEnhancer.self)
+
+        (actions[.enhance] as? EnhanceAction)?.blockEnhancer = updatedEnhancer
+
+        // UTXOFetcher
+        let updatedUTXOFetcher = container.resolve(UTXOFetcher.self)
+
+        (actions[.fetchUTXO] as? FetchUTXOsAction)?.utxoFetcher = updatedUTXOFetcher
+    }
+}
+
 // MARK: - Events
 
 extension CompactBlockProcessor {
@@ -478,6 +516,7 @@ extension CompactBlockProcessor {
     // swiftlint:disable:next cyclomatic_complexity
     private func run() async {
         logger.debug("Starting run")
+        metrics.cbpStart()
         await resetContext()
 
         while true {
@@ -513,6 +552,7 @@ extension CompactBlockProcessor {
                 try Task.checkCancellation()
 
                 // Execute action.
+                metrics.actionStart(state)
                 context = try await action.run(with: context) { [weak self] event in
                     await self?.send(event: event)
                     if let progressChanged = await self?.compactBlockProgress.hasProgressUpdated(event), progressChanged {
@@ -528,7 +568,27 @@ extension CompactBlockProcessor {
                 await stopAllActions()
                 logger.error("Sync failed with error: \(error)")
 
-                if Task.isCancelled {
+                // catching the service errors
+                let serviceError: Bool
+                switch error {
+                case ZcashError.serviceGetInfoFailed, ZcashError.serviceLatestBlockFailed,
+                    ZcashError.serviceLatestBlockHeightFailed, ZcashError.serviceBlockRangeFailed,
+                    ZcashError.serviceSubmitFailed, ZcashError.serviceFetchTransactionFailed,
+                    ZcashError.serviceFetchUTXOsFailed, ZcashError.serviceBlockStreamFailed,
+                    ZcashError.serviceSubtreeRootsStreamFailed: serviceError = true
+                default: serviceError = false
+                }
+
+                if serviceError && self.serviceFailureRetryAttempts < ZcashSDK.serviceFailureRetries {
+                    // This may be false positive communication error that is usually resolved by retry.
+                    // We will try to reset the sync and continue but this will we done at most `ZcashSDK.serviceFailureRetries` times.
+                    logger.error("ServiceError: \(error), retry is available, starting the sync all over again.")
+
+                    self.serviceFailureRetryAttempts += 1
+                    
+                    // Start sync all over again
+                    await resetContext()
+                } else if Task.isCancelled {
                     logger.info("Processing cancelled.")
                     do {
                         if try await syncTaskWasCancelled() {
@@ -543,13 +603,8 @@ extension CompactBlockProcessor {
                         break
                     }
                 } else {
-                    if await handleSyncFailure(action: action, error: error) {
-                        // Start sync all over again
-                        await resetContext()
-                    } else {
-                        // end the sync loop
-                        break
-                    }
+                    await handleSyncFailure(action: action, error: error)
+                    break
                 }
             }
         }
@@ -565,15 +620,13 @@ extension CompactBlockProcessor {
         return try await handleAfterSyncHooks()
     }
 
-    private func handleSyncFailure(action: Action, error: Error) async -> Bool {
+    private func handleSyncFailure(action: Action, error: Error) async {
         if action.removeBlocksCacheWhenFailed {
             await ifTaskIsNotCanceledClearCompactBlockCache()
         }
 
         logger.error("Sync failed with error: \(error)")
         await failure(error)
-
-        return false
     }
 
     // swiftlint:disable:next cyclomatic_complexity
@@ -640,6 +693,7 @@ extension CompactBlockProcessor {
             latestBlockHeightWhenSyncing > 0 && latestBlockHeightWhenSyncing < latestBlockHeight
 
         retryAttempts = 0
+        serviceFailureRetryAttempts = 0
         consecutiveChainValidationErrors = 0
 
         let lastScannedHeight = await latestBlocksDataProvider.maxScannedHeight
@@ -649,6 +703,9 @@ extension CompactBlockProcessor {
         await send(event: .finished(lastScannedHeight))
         await context.update(state: .finished)
 
+        let walletSummary = try? await rustBackend.getWalletSummary()
+        await metrics.logCBPOverviewReport(logger, walletSummary: walletSummary)
+
         // If new blocks were mined during previous sync run the sync process again
         if newerBlocksWereMinedDuringSync {
             return true
@@ -777,21 +834,6 @@ extension CompactBlockProcessor {
     func getTransparentAddress(accountIndex: Int) async throws -> TransparentAddress {
         try await getUnifiedAddress(accountIndex: accountIndex).transparentReceiver()
     }
-    
-    func getTransparentBalance(accountIndex: Int) async throws -> WalletBalance {
-        guard accountIndex >= 0 else {
-            throw ZcashError.compactBlockProcessorInvalidAccount
-        }
-
-        return WalletBalance(
-            verified: Zatoshi(
-                try await rustBackend.getVerifiedTransparentBalance(account: Int32(accountIndex))
-            ),
-            total: Zatoshi(
-                try await rustBackend.getTransparentBalance(account: Int32(accountIndex))
-            )
-        )
-    }
 }
 
 extension CompactBlockProcessor {

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

@@ -195,44 +195,18 @@ actor BlockDownloaderImpl {
         var buffer: [ZcashCompactBlock] = []
         logger.debug("Downloading blocks in range: \(range.lowerBound)...\(range.upperBound)")
 
-        var startTime = Date()
-        var counter = 0
-        var lastDownloadedBlockHeight = -1
-
-        let pushMetrics: (BlockHeight, Date, Date) -> Void = { [metrics] _, startTime, finishTime in
-            metrics.pushProgressReport(
-                start: startTime,
-                end: finishTime,
-                batchSize: maxBlockBufferSize,
-                operation: .downloadBlocks
-            )
-        }
-
         for _ in stride(from: range.lowerBound, to: range.upperBound + 1, by: 1) {
             try Task.checkCancellation()
             guard let block = try await stream.nextBlock() else { break }
 
-            counter += 1
-            lastDownloadedBlockHeight = block.height
-
             buffer.append(block)
             if buffer.count >= maxBlockBufferSize {
-                let finishTime = Date()
                 try await storage.write(blocks: buffer)
                 try await blocksBufferWritten(buffer)
                 buffer.removeAll(keepingCapacity: true)
-
-                pushMetrics(block.height, startTime, finishTime)
-
-                counter = 0
-                startTime = finishTime
             }
         }
 
-        if counter > 0 {
-            pushMetrics(lastDownloadedBlockHeight, startTime, Date())
-        }
-
         try await storage.write(blocks: buffer)
         try await blocksBufferWritten(buffer)
     }

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

@@ -96,6 +96,7 @@ extension BlockEnhancerImpl: BlockEnhancer {
 
             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)")
                 return nil
             }
 
@@ -134,12 +135,10 @@ extension BlockEnhancerImpl: BlockEnhancer {
                 }
             }
             
-            metrics.pushProgressReport(
-                start: startTime,
-                end: Date(),
-                batchSize: range.count,
-                operation: .enhancement
-            )
+            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/Block/FetchUnspentTxOutputs/UTXOFetcher.swift

@@ -23,7 +23,6 @@ protocol UTXOFetcher {
 }
 
 struct UTXOFetcherImpl {
-    let accountRepository: AccountRepository
     let blockDownloaderService: BlockDownloaderService
     let config: UTXOFetcherConfig
     let rustBackend: ZcashRustBackendWelding
@@ -37,8 +36,7 @@ extension UTXOFetcherImpl: UTXOFetcher {
     ) async throws -> (inserted: [UnspentTransactionOutputEntity], skipped: [UnspentTransactionOutputEntity]) {
         try Task.checkCancellation()
 
-        let accounts = try accountRepository.getAll()
-            .map { $0.account }
+        let accounts = try await rustBackend.listAccounts()
 
         var tAddresses: [TransparentAddress] = []
         for account in accounts {
@@ -62,7 +60,6 @@ extension UTXOFetcherImpl: UTXOFetcher {
         var refreshed: [UnspentTransactionOutputEntity] = []
         var skipped: [UnspentTransactionOutputEntity] = []
 
-        let startTime = Date()
         let all = Float(utxos.count)
         var counter = Float(0)
         for utxo in utxos {
@@ -85,13 +82,6 @@ extension UTXOFetcherImpl: UTXOFetcher {
             }
         }
 
-        metrics.pushProgressReport(
-            start: startTime,
-            end: Date(),
-            batchSize: 1,
-            operation: .fetchUTXOs
-        )
-
         let result = (inserted: refreshed, skipped: skipped)
 
         if Task.isCancelled {

package/ios/ZCashLightClientKit/Block/SaplingParameters/SaplingParametersHandler.swift

@@ -1,6 +1,6 @@
 //
-//  HandleSaplingParametersIfNeeded.swift
-//  
+//  SaplingParametersHandler.swift
+//
 //
 //  Created by Lukáš Korba on 23.11.2022.
 //
@@ -28,11 +28,13 @@ extension SaplingParametersHandlerImpl: SaplingParametersHandler {
         try Task.checkCancellation()
 
         do {
-            let totalShieldedBalance = try await rustBackend.getBalance(account: Int32(0))
+            let totalSaplingBalance =
+                try await rustBackend.getWalletSummary()?.accountBalances[0]?.saplingBalance.total().amount
+                ?? 0
             let totalTransparentBalance = try await rustBackend.getTransparentBalance(account: Int32(0))
 
             // Download Sapling parameters only if sapling funds are detected.
-            guard totalShieldedBalance > 0 || totalTransparentBalance > 0 else { return }
+            guard totalSaplingBalance > 0 || totalTransparentBalance > 0 else { return }
         } catch {
             // if sapling balance can't be detected of we fail to obtain the balance
             // for some reason we shall not proceed to download the parameters and

package/ios/ZCashLightClientKit/Block/Scan/BlockScanner.swift

@@ -23,6 +23,7 @@ protocol BlockScanner {
 struct BlockScannerImpl {
     let config: BlockScannerConfig
     let rustBackend: ZcashRustBackendWelding
+    let service: LightWalletService
     let transactionRepository: TransactionRepository
     let metrics: SDKMetrics
     let logger: Logger
@@ -51,9 +52,14 @@ extension BlockScannerImpl: BlockScanner {
 
             let batchSize = UInt32(config.scanningBatchSize)
 
+            // TODO: [#1355] Do more with ScanSummary
+            // https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1355
+            let scanSummary: ScanSummary
             let scanStartTime = Date()
             do {
-                try await self.rustBackend.scanBlocks(fromHeight: Int32(startHeight), limit: batchSize)
+                let fromState = try await service.getTreeState(BlockID(height: startHeight - 1))
+
+                scanSummary = try await self.rustBackend.scanBlocks(fromHeight: Int32(startHeight), fromState: fromState, limit: batchSize)
             } catch {
                 logger.debug("block scanning failed with error: \(String(describing: error))")
                 throw error
@@ -61,24 +67,16 @@ extension BlockScannerImpl: BlockScanner {
 
             let scanFinishTime = Date()
 
-            // TODO: [#1259] potential bug when rustBackend.scanBlocks scan less blocks than batchSize,
-            // https://github.com/zcash/ZcashLightClientKit/issues/1259
-            lastScannedHeight = startHeight + Int(batchSize) - 1
-            
+            lastScannedHeight = scanSummary.scannedRange.upperBound - 1
+
             scannedNewBlocks = previousScannedHeight != lastScannedHeight
             if scannedNewBlocks {
                 try await didScan(lastScannedHeight, batchSize)
 
-                metrics.pushProgressReport(
-                    start: scanStartTime,
-                    end: scanFinishTime,
-                    batchSize: Int(batchSize),
-                    operation: .scanBlocks
-                )
-
                 let heightCount = lastScannedHeight - previousScannedHeight
                 let seconds = scanFinishTime.timeIntervalSinceReferenceDate - scanStartTime.timeIntervalSinceReferenceDate
                 logger.debug("Scanned \(heightCount) blocks in \(seconds) seconds")
+                logger.sync("Scanned \(heightCount) blocks in \(seconds) seconds")
             }
 
             await Task.yield()

package/ios/ZCashLightClientKit/Checkpoint/BundleCheckpointSource.swift

@@ -0,0 +1,38 @@
+//
+//  BundleCheckpointSource.swift
+//
+//
+//  Created by Francisco Gindre on 2023-10-30.
+//
+
+import Foundation
+
+struct BundleCheckpointSource: CheckpointSource {
+    var network: NetworkType
+    
+    var saplingActivation: Checkpoint
+    
+    init(network: NetworkType) {
+        self.network = network
+        self.saplingActivation = switch network {
+        case .mainnet:
+            Checkpoint.mainnetMin
+        case .testnet:
+            Checkpoint.testnetMin
+        }
+    }
+
+    func latestKnownCheckpoint() -> Checkpoint {
+        Checkpoint.birthday(
+            with: .max,
+            checkpointDirectory: BundleCheckpointURLProvider.default.url(self.network)
+        ) ?? saplingActivation
+    }
+    
+    func birthday(for height: BlockHeight) -> Checkpoint {
+        Checkpoint.birthday(
+            with: height,
+            checkpointDirectory: BundleCheckpointURLProvider.default.url(self.network)
+        ) ?? saplingActivation
+    }
+}

package/ios/ZCashLightClientKit/Checkpoint/BundleCheckpointURLProvider.swift

@@ -0,0 +1,40 @@
+//
+//  BundleCheckpointURLProvider.swift
+//  
+//
+//  Created by Francisco Gindre on 2023-10-30.
+//
+
+import Foundation
+
+struct BundleCheckpointURLProvider {
+    var url: (NetworkType) -> URL
+}
+
+extension BundleCheckpointURLProvider {
+    /// Attempts to resolve the platform. `#if os(macOS)` implies that the build is for a macOS
+    /// target, otherwise we assume the build is for an iOS target.
+    static let `default` = BundleCheckpointURLProvider { networkType in
+        #if os(macOS)
+        Self.macOS.url(networkType)
+        #else
+        Self.iOS.url(networkType)
+        #endif
+    }
+
+    static let iOS = BundleCheckpointURLProvider(url: { networkType in
+        switch networkType {
+        case .mainnet:
+            return Checkpoint.mainnetCheckpointDirectory
+        case .testnet:
+            return Checkpoint.testnetCheckpointDirectory
+        }
+    })
+
+    /// This variant attempts to retrieve the saplingActivation checkpoint for the given network
+    /// type using `Bundle.module.url(forResource:withExtension:subdirectory:localization)`.
+    /// If not found it will return `WalletBirthday.mainnetCheckpointDirectory` or
+    /// `WalletBirthday.testnetCheckpointDirectory`. This responds to tests failing on a macOS
+    /// target because the checkpoint resources would not be found.
+    
+}

package/ios/ZCashLightClientKit/{Constants/Checkpoint+Constants.swift → Checkpoint/Checkpoint+helpers.swift}

@@ -1,5 +1,5 @@
 //
-//  WalletBirthday+Constants.swift
+//  Checkpoint+helpers.swift
 //  ZcashLightClientKit
 //
 //  Created by Francisco Gindre on 7/28/21.
@@ -64,35 +64,3 @@ extension Checkpoint {
         }
     }
 }
-
-struct BundleCheckpointURLProvider {
-    var url: (NetworkType) -> URL
-}
-
-extension BundleCheckpointURLProvider {
-    /// Attempts to resolve the platform by checking `#if os(macOS)` build corresponds to a MacOS target
-    /// `#else` branch of that condition will assume iOS is the target platform
-    static let `default` = BundleCheckpointURLProvider { networkType in
-        #if os(macOS)
-        Self.macOS.url(networkType)
-        #else
-        Self.iOS.url(networkType)
-        #endif
-    }
-
-    static let iOS = BundleCheckpointURLProvider(url: { networkType in
-        switch networkType {
-        case .mainnet:
-            return Checkpoint.mainnetCheckpointDirectory
-        case .testnet:
-            return Checkpoint.testnetCheckpointDirectory
-        }
-    })
-
-    /// This variant attempts to retrieve the saplingActivation checkpoint for the given network type
-    /// using `Bundle.module.url(forResource:withExtension:subdirectory:localization)`
-    /// if not found it will return `WalletBirthday.mainnetCheckpointDirectory` or
-    /// `WalletBirthday.testnetCheckpointDirectory`. This responds to tests
-    /// failing on MacOS target because the checkpoint resources would fail.
-    
-}

package/ios/ZCashLightClientKit/Checkpoint/CheckpointSource.swift

@@ -0,0 +1,34 @@
+//
+//  CheckpointSource.swift
+//
+//
+//  Created by Francisco Gindre on 2023-10-30.
+//
+
+import Foundation
+
+/// A protocol that abstracts the requirements around obtaining wallet checkpoints
+/// (also known as TreeStates).
+protocol CheckpointSource {
+    /// `NetworkType` of this Checkpoint source
+    var network: NetworkType { get }
+
+    /// The `Checkpoint` that represents the block in which Sapling was activated
+    var saplingActivation: Checkpoint { get }
+
+    /// Obtain the latest `Checkpoint` in terms of block height known by
+    /// this `CheckpointSource`. It is possible that the returned checkpoint
+    /// is not the latest checkpoint that exists in the blockchain.
+    /// - Returns a `Checkpoint` with the highest height known by this source
+    func latestKnownCheckpoint() -> Checkpoint
+
+    /// Obtain a `Checkpoint` in terms of a "wallet birthday". Wallet birthday
+    /// is estimated to be the latest height of the Zcash blockchain at the moment when the wallet was
+    /// created.
+    /// - Parameter height: Estimated or effective height known for the wallet birthday
+    /// - Returns: a `Checkpoint` that will allow the wallet to manage funds from the given `height`
+    /// onwards.
+    /// - Note: When the user knows the exact height of the first received funds for a wallet,
+    /// the effective birthday of that wallet is `transaction.height - 1`.
+    func birthday(for height: BlockHeight) -> Checkpoint
+}

package/ios/ZCashLightClientKit/Checkpoint/CheckpointSourceFactory.swift

@@ -0,0 +1,14 @@
+//
+//  CheckpointSourceFactory.swift
+//
+//
+//  Created by Francisco Gindre on 2023-10-30.
+//
+
+import Foundation
+
+struct CheckpointSourceFactory {
+    static func fromBundle(for network: NetworkType) -> CheckpointSource {
+        BundleCheckpointSource(network: network)
+    }
+}