react-native-zcash 0.3.4 → 0.4.0

package/ios/ZCashLightClientKit/Block/Utils/AfterSyncHooksManager.swift

@@ -0,0 +1,88 @@
+//
+//  AfterSyncHooksManager.swift
+//  
+//
+//  Created by Michal Fousek on 20.02.2023.
+//
+
+import Foundation
+
+class AfterSyncHooksManager {
+    struct WipeContext {
+        let prewipe: () -> Void
+        let completion: (Error?) async -> Void
+    }
+
+    struct RewindContext {
+        let height: BlockHeight?
+        let completion: (Result<BlockHeight, Error>) async -> Void
+    }
+
+    enum Hook: Equatable, Hashable {
+        case anotherSync
+        case rewind(RewindContext)
+        case wipe(WipeContext)
+
+        static func == (lhs: Hook, rhs: Hook) -> Bool {
+            switch (lhs, rhs) {
+            case (.anotherSync, .anotherSync):
+                return true
+            case (.rewind, .rewind):
+                return true
+            case (.wipe, .wipe):
+                return true
+            default:
+                return false
+            }
+        }
+
+        func hash(into hasher: inout Hasher) {
+            switch self {
+            case .anotherSync: hasher.combine(0)
+            case .rewind: hasher.combine(1)
+            case .wipe: hasher.combine(2)
+            }
+        }
+
+        static var emptyRewind: Hook {
+            return .rewind(RewindContext(height: nil, completion: { _ in }))
+        }
+
+        static var emptyWipe: Hook {
+            return .wipe(
+                WipeContext(
+                    prewipe: { },
+                    completion: { _ in }
+                )
+            )
+        }
+    }
+
+    private var hooks: Set<Hook> = []
+
+    init() { }
+
+    func insert(hook: Hook) {
+        hooks.insert(hook)
+    }
+
+    func shouldExecuteAnotherSyncHook() -> Bool {
+        return hooks.first(where: { $0 == .anotherSync }) != nil
+    }
+
+    func shouldExecuteWipeHook() -> WipeContext? {
+        if case let .wipe(wipeContext) = hooks.first(where: { $0 == Hook.emptyWipe }) {
+            return wipeContext
+        } else {
+            return nil
+        }
+    }
+
+    func shouldExecuteRewindHook() -> RewindContext? {
+        if case let .rewind(rewindContext) = hooks.first(where: { $0 == Hook.emptyRewind }) {
+            return rewindContext
+        } else {
+            return nil
+        }
+    }
+}

package/ios/ZCashLightClientKit/Block/Utils/InternalSyncProgress.swift

@@ -0,0 +1,200 @@
+//
+//  InternalSyncProgress.swift
+//  
+//
+//  Created by Michal Fousek on 23.11.2022.
+//
+
+import Foundation
+
+struct SyncRanges: Equatable {
+    let latestBlockHeight: BlockHeight
+    /// The sync process can be interrupted in any phase. It may happen that it's interrupted while downloading blocks. In that case in next sync
+    /// process already downloaded blocks needs to be scanned before the sync process starts to download new blocks. And the range of blocks that are
+    /// already downloaded but not scanned is stored in this variable.
+    let downloadedButUnscannedRange: CompactBlockRange?
+    /// Range of blocks that are not yet downloaded and not yet scanned.
+    let downloadAndScanRange: CompactBlockRange?
+    /// Range of blocks that are not enhanced yet.
+    let enhanceRange: CompactBlockRange?
+    /// Range of blocks for which no UTXOs are fetched yet.
+    let fetchUTXORange: CompactBlockRange?
+
+    let latestScannedHeight: BlockHeight?
+
+    let latestDownloadedBlockHeight: BlockHeight?
+}
+
+protocol InternalSyncProgressStorage {
+    func bool(forKey defaultName: String) -> Bool
+    func integer(forKey defaultName: String) -> Int
+    func set(_ value: Int, forKey defaultName: String)
+    func set(_ value: Bool, forKey defaultName: String)
+    @discardableResult
+    func synchronize() -> Bool
+}
+
+extension UserDefaults: InternalSyncProgressStorage { }
+
+actor InternalSyncProgress {
+    enum Key: String, CaseIterable {
+        case latestDownloadedBlockHeight
+        case latestEnhancedHeight
+        case latestUTXOFetchedHeight
+
+        func with(_ alias: ZcashSynchronizerAlias) -> String {
+            switch alias {
+            case .`default`:
+                return self.rawValue
+            case let .custom(rawAlias):
+                return "\(self.rawValue)_\(rawAlias)"
+            }
+        }
+    }
+
+    private let alias: ZcashSynchronizerAlias
+    private let storage: InternalSyncProgressStorage
+    let logger: Logger
+
+    var latestDownloadedBlockHeight: BlockHeight { load(.latestDownloadedBlockHeight) }
+    var latestEnhancedHeight: BlockHeight { load(.latestEnhancedHeight) }
+    var latestUTXOFetchedHeight: BlockHeight { load(.latestUTXOFetchedHeight) }
+
+    init(alias: ZcashSynchronizerAlias, storage: InternalSyncProgressStorage, logger: Logger) {
+        self.alias = alias
+        self.storage = storage
+        self.logger = logger
+    }
+
+    func load(_ key: Key) -> BlockHeight {
+        storage.integer(forKey: key.with(alias))
+    }
+
+    func set(_ value: BlockHeight, _ key: Key) {
+        storage.set(value, forKey: key.with(alias))
+        storage.synchronize()
+    }
+
+    func rewind(to: BlockHeight) {
+        Key.allCases.forEach { key in
+            let finalRewindHeight = min(load(key), to)
+            self.set(finalRewindHeight, key)
+        }
+    }
+
+    /// `InternalSyncProgress` is from now on used to track which block were already downloaded. Previous versions of the SDK were using cache DB to
+    /// track this. Because of this we have to migrate height of latest downloaded block from cache DB to here.
+    ///
+    /// - Parameter latestDownloadedBlockHeight: Height of latest downloaded block from cache DB.
+    func migrateIfNeeded(latestDownloadedBlockHeightFromCacheDB latestDownloadedBlockHeight: BlockHeight) {
+        let key = "InternalSyncProgressMigrated"
+        if !storage.bool(forKey: key) {
+            set(latestDownloadedBlockHeight, .latestDownloadedBlockHeight)
+        }
+        storage.set(true, forKey: key)
+        storage.synchronize()
+    }
+
+    /// Computes the next state for the sync process. Thanks to this it's possible to interrupt the sync process at any phase and then it can be safely
+    /// resumed.
+    ///
+    /// The sync process has 4 phases (download, scan, enhance, fetch UTXO). `InternalSyncProgress` tracks independently which blocks were already
+    /// processed in each phase. To compute the next state these 4 numbers are compared with `latestBlockHeight`.
+    ///
+    /// - If any of these numbers are larger than `latestBlockHeight` then `wait` is used as the next state. We have locally higher block heights than
+    ///   are currently available at LightWalletd.
+    /// - If any of these numbers are lower than `latestBlockHeight` then `processNewBlocks` is used as the next state. The sync process should run.
+    /// - Otherwise `finishProcessing` is used as the next state. It means that local data are synced with what is available at LightWalletd.
+    ///
+    /// - Parameters:
+    ///   - latestBlockHeight: Latest height fetched from LightWalletd API.
+    ///   - latestScannedHeight: Latest height of latest block scanned.
+    ///   - walletBirthday: Wallet birthday.
+    /// - Returns: Computed state.
+    func computeNextState(
+        latestBlockHeight: BlockHeight,
+        latestScannedHeight: BlockHeight,
+        walletBirthday: BlockHeight
+    ) -> CompactBlockProcessor.NextState {
+        logger.debug("""
+            Init numbers:
+            latestBlockHeight:       \(latestBlockHeight)
+            latestDownloadedHeight:  \(latestDownloadedBlockHeight)
+            latestScannedHeight:     \(latestScannedHeight)
+            latestEnhancedHeight:    \(latestEnhancedHeight)
+            latestUTXOFetchedHeight: \(latestUTXOFetchedHeight)
+            """)
+
+        if  latestDownloadedBlockHeight > latestBlockHeight ||
+            latestScannedHeight > latestBlockHeight ||
+            latestEnhancedHeight > latestBlockHeight ||
+            latestUTXOFetchedHeight > latestBlockHeight {
+            return .wait(latestHeight: latestBlockHeight, latestDownloadHeight: latestDownloadedBlockHeight)
+        } else if latestDownloadedBlockHeight < latestBlockHeight ||
+            latestScannedHeight < latestBlockHeight ||
+            latestEnhancedHeight < latestEnhancedHeight ||
+            latestUTXOFetchedHeight < latestBlockHeight {
+            let ranges = computeSyncRanges(
+                birthday: walletBirthday,
+                latestBlockHeight: latestBlockHeight,
+                latestScannedHeight: latestScannedHeight
+            )
+            return .processNewBlocks(ranges: ranges)
+        } else {
+            return .finishProcessing(height: latestBlockHeight)
+        }
+    }
+
+    func computeSyncRanges(
+        birthday: BlockHeight,
+        latestBlockHeight: BlockHeight,
+        latestScannedHeight: BlockHeight
+    ) -> SyncRanges {
+        // If there is more downloaded then scanned blocks we have to range for these blocks. The sync process will then start with scanning these
+        // blocks instead of downloading new ones.
+        let downloadedButUnscannedRange: CompactBlockRange?
+        if latestScannedHeight < latestDownloadedBlockHeight {
+            downloadedButUnscannedRange = latestScannedHeight + 1...latestDownloadedBlockHeight
+        } else {
+            downloadedButUnscannedRange = nil
+        }
+
+        if latestScannedHeight > latestDownloadedBlockHeight {
+            logger.warn("""
+            InternalSyncProgress found inconsistent state.
+                latestBlockHeight:       \(latestBlockHeight)
+            --> latestDownloadedHeight:  \(latestDownloadedBlockHeight)
+                latestScannedHeight:     \(latestScannedHeight)
+                latestEnhancedHeight:    \(latestEnhancedHeight)
+                latestUTXOFetchedHeight: \(latestUTXOFetchedHeight)
+
+            latest downloaded height
+            """)
+        }
+
+        // compute the range that must be downloaded and scanned based on
+        // birthday, `latestDownloadedBlockHeight`, `latestScannedHeight` and
+        // latest block height fetched from the chain.
+        let downloadAndScanRange = computeRange(
+            latestHeight: max(latestDownloadedBlockHeight, latestScannedHeight),
+            birthday: birthday,
+            latestBlockHeight: latestBlockHeight
+        )
+
+        return SyncRanges(
+            latestBlockHeight: latestBlockHeight,
+            downloadedButUnscannedRange: downloadedButUnscannedRange,
+            downloadAndScanRange: downloadAndScanRange,
+            enhanceRange: computeRange(latestHeight: latestEnhancedHeight, birthday: birthday, latestBlockHeight: latestBlockHeight),
+            fetchUTXORange: computeRange(latestHeight: latestUTXOFetchedHeight, birthday: birthday, latestBlockHeight: latestBlockHeight),
+            latestScannedHeight: latestScannedHeight,
+            latestDownloadedBlockHeight: latestDownloadedBlockHeight
+        )
+    }
+
+    private func computeRange(latestHeight: BlockHeight, birthday: BlockHeight, latestBlockHeight: BlockHeight) -> CompactBlockRange? {
+        guard latestHeight < latestBlockHeight else { return nil }
+        let lowerBound = latestHeight <= birthday ? birthday : latestHeight + 1
+        return lowerBound...latestBlockHeight
+    }
+}

package/ios/ZCashLightClientKit/Block/Validate/BlockValidator.swift

@@ -0,0 +1,51 @@
+//
+//  CompactBlockValidationInformation.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/30/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+protocol BlockValidator {
+    /// Validate all the downloaded blocks that haven't been yet validated.
+    func validate() async throws
+}
+
+struct BlockValidatorImpl {
+    let rustBackend: ZcashRustBackendWelding
+    let metrics: SDKMetrics
+    let logger: Logger
+}
+
+extension BlockValidatorImpl: BlockValidator {
+    /// - Throws:
+    ///  - `rustValidateCombinedChainValidationFailed` if there was an error during validation unrelated to chain validity.
+    ///  - `rustValidateCombinedChainInvalidChain(upperBound)` if the combined chain is invalid. `upperBound` is the height of the highest invalid
+    ///    block(on the assumption that the highest block in the cache database is correct).
+    func validate() async throws {
+        try Task.checkCancellation()
+
+        let startTime = Date()
+        do {
+            try await rustBackend.validateCombinedChain(limit: 0)
+            pushProgressReport(startTime: startTime, finishTime: Date())
+            logger.debug("validateChainFinished")
+        } catch {
+            logger.debug("Validate chain failed with \(error)")
+            pushProgressReport(startTime: startTime, finishTime: Date())
+            throw error
+        }
+    }
+
+    private func pushProgressReport(startTime: Date, finishTime: Date) {
+        metrics.pushProgressReport(
+            progress: BlockProgress(startHeight: 0, targetHeight: 0, progressHeight: 0),
+            start: startTime,
+            end: finishTime,
+            batchSize: 0,
+            operation: .validateBlocks
+        )
+    }
+}

package/ios/ZCashLightClientKit/ClosureSynchronizer.swift

@@ -0,0 +1,84 @@
+//
+//  ClosureSynchronizer.swift
+//  
+//
+//  Created by Michal Fousek on 20.03.2023.
+//
+
+import Combine
+import Foundation
+
+/// This defines closure-based API for the SDK. It's expected that the implementation of this protocol is only a very thin layer that translates async
+/// API defined in `Synchronizer` to closure-based API. And it doesn't do anything else. It's here so each client can choose the API that suits its
+/// case the best.
+///
+/// If you are looking for documentation for a specific method or property look for it in the `Synchronizer` protocol.
+public protocol ClosureSynchronizer {
+    var alias: ZcashSynchronizerAlias { get }
+
+    var latestState: SynchronizerState { get }
+    var connectionState: ConnectionState { get }
+
+    var stateStream: AnyPublisher<SynchronizerState, Never> { get }
+    var eventStream: AnyPublisher<SynchronizerEvent, Never> { get }
+
+    func prepare(
+        with seed: [UInt8]?,
+        viewingKeys: [UnifiedFullViewingKey],
+        walletBirthday: BlockHeight,
+        completion: @escaping (Result<Initializer.InitializationResult, Error>) -> Void
+    )
+
+    func start(retry: Bool, completion: @escaping (Error?) -> Void)
+    func stop()
+
+    func getSaplingAddress(accountIndex: Int, completion: @escaping (Result<SaplingAddress, Error>) -> Void)
+    func getUnifiedAddress(accountIndex: Int, completion: @escaping (Result<UnifiedAddress, Error>) -> Void)
+    func getTransparentAddress(accountIndex: Int, completion: @escaping (Result<TransparentAddress, Error>) -> Void)
+
+    func sendToAddress(
+        spendingKey: UnifiedSpendingKey,
+        zatoshi: Zatoshi,
+        toAddress: Recipient,
+        memo: Memo?,
+        completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
+    )
+
+    func shieldFunds(
+        spendingKey: UnifiedSpendingKey,
+        memo: Memo,
+        shieldingThreshold: Zatoshi,
+        completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
+    )
+
+    func pendingTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void)
+    func clearedTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void)
+    func sentTranscations(completion: @escaping ([ZcashTransaction.Overview]) -> Void)
+    func receivedTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void)
+    func paginatedTransactions(of kind: TransactionKind) -> PaginatedTransactionRepository
+    func getMemos(for transaction: ZcashTransaction.Overview, completion: @escaping (Result<[Memo], Error>) -> Void)
+    func getRecipients(for transaction: ZcashTransaction.Overview, completion: @escaping ([TransactionRecipient]) -> Void)
+
+    func allConfirmedTransactions(
+        from transaction: ZcashTransaction.Overview,
+        limit: Int,
+        completion: @escaping (Result<[ZcashTransaction.Overview], Error>) -> Void
+    )
+
+    func latestHeight(completion: @escaping (Result<BlockHeight, Error>) -> Void)
+
+    func refreshUTXOs(address: TransparentAddress, from height: BlockHeight, completion: @escaping (Result<RefreshedUTXOs, Error>) -> Void)
+
+    func getTransparentBalance(accountIndex: Int, completion: @escaping (Result<WalletBalance, Error>) -> Void)
+
+    func getShieldedBalance(accountIndex: Int, completion: @escaping (Result<Zatoshi, Error>) -> Void)
+
+    func getShieldedVerifiedBalance(accountIndex: Int, completion: @escaping (Result<Zatoshi, Error>) -> Void)
+
+    /*
+     It can be missleading that these two methods are returning Publisher even this protocol is closure based. Reason is that Synchronizer doesn't
+     provide different implementations for these two methods. So Combine it is even here.
+     */
+    func rewind(_ policy: RewindPolicy) -> CompletablePublisher<Error>
+    func wipe() -> CompletablePublisher<Error>
+}

package/ios/ZCashLightClientKit/CombineSynchronizer.swift

@@ -0,0 +1,76 @@
+//
+//  CombineSynchronizer.swift
+//  
+//
+//  Created by Michal Fousek on 16.03.2023.
+//
+
+import Combine
+import Foundation
+
+/// This defines a Combine-based API for the SDK. It's expected that the implementation of this protocol is only a very thin layer that translates
+/// async API defined in `Synchronizer` to Combine-based API. And it doesn't do anything else. It's here so each client can choose the API that suits
+/// its case the best.
+///
+/// If you are looking for documentation for a specific method or property look for it in the `Synchronizer` protocol.
+public protocol CombineSynchronizer {
+    var alias: ZcashSynchronizerAlias { get }
+
+    var latestState: SynchronizerState { get }
+    var connectionState: ConnectionState { get }
+
+    var stateStream: AnyPublisher<SynchronizerState, Never> { get }
+    var eventStream: AnyPublisher<SynchronizerEvent, Never> { get }
+
+    func prepare(
+        with seed: [UInt8]?,
+        viewingKeys: [UnifiedFullViewingKey],
+        walletBirthday: BlockHeight
+    ) -> SinglePublisher<Initializer.InitializationResult, Error>
+
+    func start(retry: Bool) -> CompletablePublisher<Error>
+    func stop()
+
+    func getSaplingAddress(accountIndex: Int) -> SinglePublisher<SaplingAddress, Error>
+    func getUnifiedAddress(accountIndex: Int) -> SinglePublisher<UnifiedAddress, Error>
+    func getTransparentAddress(accountIndex: Int) -> SinglePublisher<TransparentAddress, Error>
+
+    func sendToAddress(
+        spendingKey: UnifiedSpendingKey,
+        zatoshi: Zatoshi,
+        toAddress: Recipient,
+        memo: Memo?
+    ) -> SinglePublisher<ZcashTransaction.Overview, Error>
+
+    func shieldFunds(
+        spendingKey: UnifiedSpendingKey,
+        memo: Memo,
+        shieldingThreshold: Zatoshi
+    ) -> SinglePublisher<ZcashTransaction.Overview, Error>
+
+    var allTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
+    var pendingTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
+    var sentTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
+    var receivedTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
+
+    func paginatedTransactions(of kind: TransactionKind) -> PaginatedTransactionRepository
+
+    func getMemos(for transaction: ZcashTransaction.Overview) -> SinglePublisher<[Memo], Error>
+
+    func getRecipients(for transaction: ZcashTransaction.Overview) -> SinglePublisher<[TransactionRecipient], Never>
+
+    func allPendingTransactions() -> SinglePublisher<[ZcashTransaction.Overview], Error>
+
+    func allTransactions(from transaction: ZcashTransaction.Overview, limit: Int) -> SinglePublisher<[ZcashTransaction.Overview], Error>
+
+    func latestHeight() -> SinglePublisher<BlockHeight, Error>
+
+    func refreshUTXOs(address: TransparentAddress, from height: BlockHeight) -> SinglePublisher<RefreshedUTXOs, Error>
+
+    func getTransparentBalance(accountIndex: Int) -> SinglePublisher<WalletBalance, Error>
+    func getShieldedBalance(accountIndex: Int) -> SinglePublisher<Zatoshi, Error>
+    func getShieldedVerifiedBalance(accountIndex: Int) -> SinglePublisher<Zatoshi, Error>
+
+    func rewind(_ policy: RewindPolicy) -> CompletablePublisher<Error>
+    func wipe() -> CompletablePublisher<Error>
+}

package/ios/ZCashLightClientKit/Constants/Checkpoint+Constants.swift

@@ -0,0 +1,98 @@
+//
+//  WalletBirthday+Constants.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 7/28/21.
+//
+
+import Foundation
+
+extension Checkpoint {
+    static func birthday(with height: BlockHeight, network: ZcashNetwork) -> Checkpoint {
+        let checkpointDirectoryURL = BundleCheckpointURLProvider.default.url(network.networkType)
+
+        switch network.networkType {
+        case .mainnet:
+            return birthday(with: height, checkpointDirectory: checkpointDirectoryURL) ?? .mainnetMin
+        case .testnet:
+            return birthday(with: height, checkpointDirectory: checkpointDirectoryURL) ?? .testnetMin
+        }
+    }
+}
+
+extension Checkpoint {
+    static func birthday(with height: BlockHeight, checkpointDirectory: URL) -> Checkpoint? {
+        return bestCheckpointHeight(for: height, checkpointDirectory: checkpointDirectory)
+            .flatMap { checkpoint(height: $0, directory: checkpointDirectory) }
+    }
+
+    private static func bestCheckpointHeight(for height: BlockHeight, checkpointDirectory: URL) -> Int? {
+        guard let checkPointURLs = try? FileManager.default.contentsOfDirectory(
+            at: checkpointDirectory,
+            includingPropertiesForKeys: nil,
+            options: .skipsHiddenFiles
+        ) else {
+            return nil
+        }
+
+        return checkPointURLs
+            .map { $0.deletingPathExtension() }
+            .map(\.lastPathComponent)
+            .compactMap(Int.init)
+            .filter { $0 <= height }
+            .sorted()
+            .last
+    }
+
+    private static func checkpoint(height: BlockHeight, directory checkpointDirectory: URL) -> Checkpoint? {
+        let url = checkpointDirectory
+            .appendingPathComponent(String(height))
+            .appendingPathExtension("json")
+
+        return try? checkpoint(at: url)
+    }
+
+    /// - Throws:
+    ///     - `checkpointCantLoadFromDisk` if can't load JSON with checkpoint from disk.
+    private static func checkpoint(at url: URL) throws -> Checkpoint {
+        do {
+            let data = try Data(contentsOf: url)
+            let checkpoint = try JSONDecoder().decode(Checkpoint.self, from: data)
+            return checkpoint
+        } catch {
+            throw ZcashError.checkpointCantLoadFromDisk(error)
+        }
+    }
+}
+
+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/Constants/Checkpoint+mainnet.swift

@@ -0,0 +1,19 @@
+//
+//  WalletBirthday+mainnet.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 7/28/21.
+//
+import Foundation
+
+extension Checkpoint {
+    static let mainnetMin = Checkpoint(
+        height: 419_200,
+        hash: "00000000025a57200d898ac7f21e26bf29028bbe96ec46e05b2c17cc9db9e4f3",
+        time: 1540779337,
+        saplingTree: "000000",
+        orchardTree: nil
+    )
+
+    static let mainnetCheckpointDirectory = Bundle.main.url(forResource: "zcash-mainnet", withExtension: "bundle")!
+}

package/ios/ZCashLightClientKit/Constants/Checkpoint+testnet.swift

@@ -0,0 +1,20 @@
+//
+//  WalletBirthday+testnet.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 7/28/21.
+//
+
+import Foundation
+
+extension Checkpoint {
+    static let testnetMin = Checkpoint(
+        height: 280000,
+        hash: "000420e7fcc3a49d729479fb0b560dd7b8617b178a08e9e389620a9d1dd6361a",
+        time: 1535262293,
+        saplingTree: "000000",
+        orchardTree: nil
+    )
+    
+    static let testnetCheckpointDirectory = Bundle.main.url(forResource: "zcash-testnet", withExtension: "bundle")!
+}