react-native-zcash 0.6.10 → 0.6.11

package/ios/ZCashLightClientKit/Synchronizer.swift

@@ -42,8 +42,13 @@ public struct SynchronizerState: Equatable {
     /// status of the whole sync process
     var internalSyncStatus: InternalSyncStatus
     public var syncStatus: SyncStatus
+    /// height of the latest scanned block known to this synchronizer.
+    public var latestScannedHeight: BlockHeight
     /// height of the latest block on the blockchain known to this synchronizer.
     public var latestBlockHeight: BlockHeight
+    /// timestamp of the latest scanned block on the blockchain known to this synchronizer.
+    /// The anchor point is timeIntervalSince1970
+    public var latestScannedTime: TimeInterval
 
     /// Represents a synchronizer that has made zero progress hasn't done a sync attempt
     public static var zero: SynchronizerState {
@@ -52,7 +57,9 @@ public struct SynchronizerState: Equatable {
             shieldedBalance: .zero,
             transparentBalance: .zero,
             internalSyncStatus: .unprepared,
-            latestBlockHeight: .zero
+            latestScannedHeight: .zero,
+            latestBlockHeight: .zero,
+            latestScannedTime: 0
         )
     }
     
@@ -61,13 +68,17 @@ public struct SynchronizerState: Equatable {
         shieldedBalance: WalletBalance,
         transparentBalance: WalletBalance,
         internalSyncStatus: InternalSyncStatus,
-        latestBlockHeight: BlockHeight
+        latestScannedHeight: BlockHeight,
+        latestBlockHeight: BlockHeight,
+        latestScannedTime: TimeInterval
     ) {
         self.syncSessionID = syncSessionID
         self.shieldedBalance = shieldedBalance
         self.transparentBalance = transparentBalance
         self.internalSyncStatus = internalSyncStatus
+        self.latestScannedHeight = latestScannedHeight
         self.latestBlockHeight = latestBlockHeight
+        self.latestScannedTime = latestScannedTime
         self.syncStatus = internalSyncStatus.mapToSyncStatus()
     }
 }
@@ -108,7 +119,7 @@ public protocol Synchronizer: AnyObject {
 
     /// An object that when enabled collects mertrics from the synchronizer
     var metrics: SDKMetrics { get }
-
+    
     /// Initialize the wallet. The ZIP-32 seed bytes can optionally be passed to perform
     /// database migrations. most of the times the seed won't be needed. If they do and are
     /// not provided this will fail with `InitializationResult.seedRequired`. It could
@@ -120,11 +131,9 @@ public protocol Synchronizer: AnyObject {
     /// do not already exist). These files can be given a prefix for scenarios where multiple wallets
     ///
     /// - Parameters:
-    ///   - seed: ZIP-32 Seed bytes for the wallet that will be initialized
+    ///   - seed: ZIP-32 Seed bytes for the wallet that will be initialized.
+    ///   - viewingKeys: Viewing key derived from seed.
     ///   - walletBirthday: Birthday of wallet.
-    ///   - for: [walletMode] Set `.newWallet` when preparing synchronizer for a brand new generated wallet,
-    ///   `.restoreWallet` when wallet is about to be restored from a seed
-    ///   and  `.existingWallet` for all other scenarios.
     /// - Throws:
     ///     - `aliasAlreadyInUse` if the Alias used to create this instance is already used by other instance.
     ///     - `cantUpdateURLWithAlias` if the updating of paths in `Initilizer` according to alias fails. When this happens it means that
@@ -133,8 +142,8 @@ public protocol Synchronizer: AnyObject {
     ///     - Some other `ZcashError` thrown by lower layer of the SDK.
     func prepare(
         with seed: [UInt8]?,
-        walletBirthday: BlockHeight,
-        for walletMode: WalletInitMode
+        viewingKeys: [UnifiedFullViewingKey],
+        walletBirthday: BlockHeight
     ) async throws -> Initializer.InitializationResult
 
     /// Starts this synchronizer within the given scope.
@@ -190,6 +199,9 @@ public protocol Synchronizer: AnyObject {
         shieldingThreshold: Zatoshi
     ) async throws -> ZcashTransaction.Overview
 
+    /// all outbound pending transactions that have been sent but are awaiting confirmations
+    var pendingTransactions: [ZcashTransaction.Overview] { get async }
+
     /// all the transactions that are on the blockchain
     var transactions: [ZcashTransaction.Overview] { get async }
 
@@ -230,6 +242,10 @@ public protocol Synchronizer: AnyObject {
     /// - Returns: an array with the given Transactions or an empty array
     func allTransactions(from transaction: ZcashTransaction.Overview, limit: Int) async throws -> [ZcashTransaction.Overview]
 
+    /// Fetch all pending transactions
+    /// - Returns: an array of transactions which are considered pending confirmation. can be empty
+    func allPendingTransactions() async throws -> [ZcashTransaction.Overview]
+
     /// Returns the latest block height from the provided Lightwallet endpoint
     func latestHeight() async throws -> BlockHeight
 
@@ -317,32 +333,20 @@ public enum SyncStatus: Equatable {
     /// When set, a UI element may want to turn green.
     case upToDate
 
-    /// Indicates that this Synchronizer was succesfully stopped via `stop()` method.
-    case stopped
-    
     case error(_ error: Error)
     
     public var isSyncing: Bool {
-        if case .syncing = self {
-            return true
-        }
-        
+        guard case .syncing = self else { return true }
         return false
     }
     
     public var isSynced: Bool {
-        if case .upToDate = self {
-            return true
-        }
-        
+        guard case .upToDate = self else { return true }
         return false
     }
 
     public var isPrepared: Bool {
-        if case .unprepared = self {
-            return false
-        }
-        
+        guard case .unprepared = self else { return false }
         return true
     }
 
@@ -350,7 +354,6 @@ public enum SyncStatus: Equatable {
         switch self {
         case .unprepared: return "unprepared"
         case .syncing: return "syncing"
-        case .stopped: return "stopped"
         case .upToDate: return "up to date"
         case .error: return "error"
         }
@@ -363,9 +366,15 @@ enum InternalSyncStatus: Equatable {
     /// taking other maintenance steps that need to occur after an upgrade.
     case unprepared
 
-    /// Indicates that this Synchronizer is actively processing new blocks (consists of fetch, scan and enhance operations)
-    case syncing(Float)
-    
+    case syncing(_ progress: BlockProgress)
+
+    /// Indicates that this Synchronizer is actively enhancing newly scanned blocks
+    /// with additional transaction details, fetched from the server.
+    case enhancing(_ progress: EnhancementProgress)
+
+    /// fetches the transparent balance and stores it locally
+    case fetching(_ progress: Float)
+
     /// Indicates that this Synchronizer is fully up to date and ready for all wallet functions.
     /// When set, a UI element may want to turn green.
     case synced
@@ -380,33 +389,35 @@ enum InternalSyncStatus: Equatable {
     case error(_ error: Error)
     
     public var isSyncing: Bool {
-        if case .syncing = self {
+        switch self {
+        case .syncing, .enhancing, .fetching:
             return true
+        default:
+            return false
         }
-        
-        return false
     }
     
     public var isSynced: Bool {
-        if case .synced = self {
-            return true
+        switch self {
+        case .synced:   return true
+        default:        return false
         }
-        
-        return false
     }
 
     public var isPrepared: Bool {
         if case .unprepared = self {
             return false
+        } else {
+            return true
         }
-        
-        return true
     }
 
     public var briefDebugDescription: String {
         switch self {
         case .unprepared: return "unprepared"
         case .syncing: return "syncing"
+        case .enhancing: return "enhancing"
+        case .fetching: return "fetching"
         case .synced: return "synced"
         case .stopped: return "stopped"
         case .disconnected: return "disconnected"
@@ -415,16 +426,6 @@ enum InternalSyncStatus: Equatable {
     }
 }
 
-/// Mode of the Synchronizer's initialization for the wallet.
-public enum WalletInitMode: Equatable {
-    /// For brand new wallet - typically when users creates a new wallet.
-    case newWallet
-    /// For a wallet that is about to be restored. Typically when a user wants to restore a wallet from a seed.
-    case restoreWallet
-    /// All other cases - typically when clients just start the process e.g. every regular app start for mobile apps.
-    case existingWallet
-}
-
 /// Kind of transactions handled by a Synchronizer
 public enum TransactionKind {
     case sent
@@ -448,6 +449,8 @@ extension InternalSyncStatus {
         switch (lhs, rhs) {
         case (.unprepared, .unprepared): return true
         case let (.syncing(lhsProgress), .syncing(rhsProgress)): return lhsProgress == rhsProgress
+        case let (.enhancing(lhsProgress), .enhancing(rhsProgress)): return lhsProgress == rhsProgress
+        case (.fetching, .fetching): return true
         case (.synced, .synced): return true
         case (.stopped, .stopped): return true
         case (.disconnected, .disconnected): return true
@@ -458,8 +461,15 @@ extension InternalSyncStatus {
 }
 
 extension InternalSyncStatus {
-    init(_ blockProcessorProgress: Float) {
-        self = .syncing(blockProcessorProgress)
+    init(_ blockProcessorProgress: CompactBlockProgress) {
+        switch blockProcessorProgress {
+        case .syncing(let progressReport):
+            self = .syncing(progressReport)
+        case .enhance(let enhancingReport):
+            self = .enhancing(enhancingReport)
+        case .fetch(let fetchingProgress):
+            self = .fetching(fetchingProgress)
+        }
     }
 }
 
@@ -469,11 +479,15 @@ extension InternalSyncStatus {
         case .unprepared:
             return .unprepared
         case .syncing(let progress):
-            return .syncing(progress)
+            return .syncing(0.9 * progress.progress)
+        case .enhancing(let progress):
+            return .syncing(0.9 + 0.08 * progress.progress)
+        case .fetching(let progress):
+            return .syncing(0.98 + 0.02 * progress)
         case .synced:
             return .upToDate
         case .stopped:
-            return .stopped
+            return .upToDate
         case .disconnected:
             return .error(ZcashError.synchronizerDisconnected)
         case .error(let error):

package/ios/ZCashLightClientKit/Transaction/TransactionEncoder.swift

@@ -10,8 +10,8 @@ import Foundation
 typealias TransactionEncoderResultBlock = (_ result: Result<EncodedTransaction, Error>) -> Void
 
 public enum TransactionEncoderError: Error {
-    case notFound(txId: Data)
-    case notEncoded(txId: Data)
+    case notFound(transactionId: Int)
+    case notEncoded(transactionId: Int)
     case missingParams
     case spendingKeyWrongNetwork
     case couldNotExpand(txId: Data)

package/ios/ZCashLightClientKit/Transaction/WalletTransactionEncoder.swift

@@ -71,7 +71,7 @@ class WalletTransactionEncoder: TransactionEncoder {
         )
 
         logger.debug("transaction id: \(txId)")
-        return try await repository.find(rawID: txId)
+        return try await repository.find(id: txId)
     }
     
     func createSpend(
@@ -80,7 +80,7 @@ class WalletTransactionEncoder: TransactionEncoder {
         to address: String,
         memoBytes: MemoBytes?,
         from accountIndex: Int
-    ) async throws -> Data {
+    ) async throws -> Int {
         guard ensureParams(spend: self.spendParamsURL, output: self.outputParamsURL) else {
             throw ZcashError.walletTransEncoderCreateTransactionMissingSaplingParams
         }
@@ -92,7 +92,7 @@ class WalletTransactionEncoder: TransactionEncoder {
             memo: memoBytes
         )
 
-        return txId
+        return Int(txId)
     }
     
     func createShieldingTransaction(
@@ -109,7 +109,7 @@ class WalletTransactionEncoder: TransactionEncoder {
         )
         
         logger.debug("transaction id: \(txId)")
-        return try await repository.find(rawID: txId)
+        return try await repository.find(id: txId)
     }
 
     func createShieldingSpend(
@@ -117,7 +117,7 @@ class WalletTransactionEncoder: TransactionEncoder {
         shieldingThreshold: Zatoshi,
         memo: MemoBytes?,
         accountIndex: Int
-    ) async throws -> Data {
+    ) async throws -> Int {
         guard ensureParams(spend: self.spendParamsURL, output: self.outputParamsURL) else {
             throw ZcashError.walletTransEncoderShieldFundsMissingSaplingParams
         }
@@ -128,7 +128,7 @@ class WalletTransactionEncoder: TransactionEncoder {
             shieldingThreshold: shieldingThreshold
         )
                 
-        return txId
+        return Int(txId)
     }
 
     func submit(
@@ -157,7 +157,7 @@ class WalletTransactionEncoder: TransactionEncoder {
 extension ZcashTransaction.Overview {
     func encodedTransaction() throws -> EncodedTransaction {
         guard let raw else {
-            throw TransactionEncoderError.notEncoded(txId: self.rawID)
+            throw TransactionEncoderError.notEncoded(transactionId: self.id)
         }
 
         return EncodedTransaction(transactionId: self.rawID, raw: raw)

package/ios/ZCashLightClientKit/Utils/OSLogger.swift

@@ -13,10 +13,10 @@ public class OSLogger: Logger {
     
     public enum LogLevel: Int {
         case debug
-        case info
-        case event
-        case warning
         case error
+        case warning
+        case event
+        case info
     }
 
     public let oslog: OSLog?

package/ios/libzcashlc.xcframework/Info.plist

@@ -5,8 +5,6 @@
 	<key>AvailableLibraries</key>
 	<array>
 		<dict>
-			<key>BinaryPath</key>
-			<string>libzcashlc.a</string>
 			<key>LibraryIdentifier</key>
 			<string>ios-arm64</string>
 			<key>LibraryPath</key>
@@ -19,8 +17,6 @@
 			<string>ios</string>
 		</dict>
 		<dict>
-			<key>BinaryPath</key>
-			<string>libzcashlc.a</string>
 			<key>LibraryIdentifier</key>
 			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-zcash",
-  "version": "0.6.10",
+  "version": "0.6.11",
   "description": "Zcash library for React Native",
   "homepage": "https://github.com/EdgeApp/react-native-zcash",
   "repository": {

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

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

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

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

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

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