react-native-zcash 0.6.12 → 0.6.13

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## 0.6.13 (2024-04-12)
+
+- fixed: Update the packaging scripts to clean leftover files.
+- fixed: Update the packaging scripts to correctly report errors, so we don't send failed packages to NPM.
+
 ## 0.6.12 (2024-04-10)
 
 - fixed: Correct packaging mistake the previous release

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "react-native-zcash",
-  "version": "0.6.12",
+  "version": "0.6.13",
   "description": "Zcash library for React Native",
   "homepage": "https://github.com/EdgeApp/react-native-zcash",
   "repository": {
     "type": "git",
-    "url": "git@github.com:EdgeApp/react-native-zcash.git"
+    "url": "git+ssh://git@github.com/EdgeApp/react-native-zcash.git"
   },
   "license": "MIT",
   "author": "Airbitz, Inc.",

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

@@ -1,200 +0,0 @@
-//
-//  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

@@ -1,51 +0,0 @@
-//
-//  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/DAO/BlockDao.swift

@@ -1,112 +0,0 @@
-//
-//  BlockDao.swift
-//  ZcashLightClientKit
-//
-//  Created by Francisco Gindre on 10/16/19.
-//  Copyright © 2019 Electric Coin Company. All rights reserved.
-//
-
-import Foundation
-import SQLite
-
-protocol BlockDao {
-    func latestBlockHeight() throws -> BlockHeight
-    func latestBlock() throws -> Block?
-    func block(at height: BlockHeight) throws -> Block?
-}
-
-struct Block: Codable {
-    enum CodingKeys: String, CodingKey {
-        case height
-        case hash
-        case time
-        case saplingTree = "sapling_tree"
-    }
-
-    enum TableStructure {
-        static let height = Expression<Int>(Block.CodingKeys.height.rawValue)
-        static let hash = Expression<Blob>(Block.CodingKeys.hash.rawValue)
-        static let time = Expression<Int>(Block.CodingKeys.time.rawValue)
-        static let saplingTree = Expression<Blob>(Block.CodingKeys.saplingTree.rawValue)
-    }
-
-    let height: BlockHeight
-    let hash: Data
-    let time: Int
-    let saplingTree: Data
-    
-    static let table = Table("blocks")
-}
-
-class BlockSQLDAO: BlockDao {
-    let dbProvider: ConnectionProvider
-    let table: Table
-    let height = Expression<Int>("height")
-
-    init(dbProvider: ConnectionProvider) {
-        self.dbProvider = dbProvider
-        self.table = Table("Blocks")
-    }
-
-    /// - Throws:
-    ///     - `blockDAOCantDecode` if block data loaded from DB can't be decoded to `Block` object.
-    ///     - `blockDAOBlock` if sqlite query to load block metadata failed.
-    func block(at height: BlockHeight) throws -> Block? {
-        do {
-            return try dbProvider
-                .connection()
-                .prepare(Block.table.filter(Block.TableStructure.height == height).limit(1))
-                .map {
-                    do {
-                        return try $0.decode()
-                    } catch {
-                        throw ZcashError.blockDAOCantDecode(error)
-                    }
-                }
-                .first
-        } catch {
-            if let error = error as? ZcashError {
-                throw error
-            } else {
-                throw ZcashError.blockDAOBlock(error)
-            }
-        }
-    }
-
-    /// - Throws: `blockDAOLatestBlockHeight` if sqlite to fetch height fails.
-    func latestBlockHeight() throws -> BlockHeight {
-        do {
-            return try dbProvider.connection().scalar(table.select(height.max)) ?? BlockHeight.empty()
-        } catch {
-            throw ZcashError.blockDAOLatestBlockHeight(error)
-        }
-    }
-    
-    func latestBlock() throws -> Block? {
-        do {
-            return try dbProvider
-                .connection()
-                .prepare(Block.table.order(height.desc).limit(1))
-                .map {
-                    do {
-                        return try $0.decode()
-                    } catch {
-                        throw ZcashError.blockDAOLatestBlockCantDecode(error)
-                    }
-                }
-                .first
-        } catch {
-            if let error = error as? ZcashError {
-                throw error
-            } else {
-                throw ZcashError.blockDAOLatestBlock(error)
-            }
-        }
-    }
-}
-
-extension BlockSQLDAO: BlockRepository {
-    func lastScannedBlockHeight() -> BlockHeight {
-        (try? self.latestBlockHeight()) ?? BlockHeight.empty()
-    }
-}

package/ios/ZCashLightClientKit/Entity/BlockProgress.swift

@@ -1,24 +0,0 @@
-//
-//  BlockProgress.swift
-//  
-//
-//  Created by Michal Fousek on 03.02.2023.
-//
-
-import Foundation
-
-public struct BlockProgress: Equatable {
-    public let startHeight: BlockHeight
-    public let targetHeight: BlockHeight
-    public let progressHeight: BlockHeight
-
-    public var progress: Float {
-        let overall = self.targetHeight - self.startHeight
-
-        return overall > 0 ? Float((self.progressHeight - self.startHeight)) / Float(overall) : 0
-    }
-}
-
-public extension BlockProgress {
-    static let nullProgress = BlockProgress(startHeight: 0, targetHeight: 0, progressHeight: 0)
-}