react-native-zcash 0.6.9 → 0.6.11

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

@@ -24,8 +24,8 @@ public protocol ClosureSynchronizer {
 
     func prepare(
         with seed: [UInt8]?,
+        viewingKeys: [UnifiedFullViewingKey],
         walletBirthday: BlockHeight,
-        for walletMode: WalletInitMode,
         completion: @escaping (Result<Initializer.InitializationResult, Error>) -> Void
     )
 
@@ -51,6 +51,7 @@ public protocol ClosureSynchronizer {
         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)

package/ios/ZCashLightClientKit/CombineSynchronizer.swift

@@ -24,8 +24,8 @@ public protocol CombineSynchronizer {
 
     func prepare(
         with seed: [UInt8]?,
-        walletBirthday: BlockHeight,
-        for walletMode: WalletInitMode
+        viewingKeys: [UnifiedFullViewingKey],
+        walletBirthday: BlockHeight
     ) -> SinglePublisher<Initializer.InitializationResult, Error>
 
     func start(retry: Bool) -> CompletablePublisher<Error>
@@ -49,6 +49,7 @@ public protocol CombineSynchronizer {
     ) -> 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 }
 
@@ -58,6 +59,8 @@ public protocol CombineSynchronizer {
 
     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>

package/ios/ZCashLightClientKit/Constants/ZcashSDK.swift

@@ -88,22 +88,24 @@ public enum ZcashSDK {
     // MARK: Defaults
 
     /// Default size of batches of blocks to request from the compact block service. Which was used both for scanning and downloading.
+    /// consider basing your code assumptions on `DefaultDownloadBatch` and `DefaultScanningBatch` instead.
+    @available(*, deprecated, message: "this value is being deprecated in favor of `DefaultDownloadBatch` and `DefaultScanningBatch`")
     public static let DefaultBatchSize = 100
-    
-    /// Default batch size for enhancing transactions for the compact block processor
-    public static let DefaultEnhanceBatch = 1000
+
+    /// Default batch size for downloading blocks for the compact block processor. Be careful with this number. This amount of blocks is held in
+    /// memory at some point of the sync process.
+    /// This values can't be smaller than `DefaultScanningBatch`. Otherwise bad things will happen.
+    public static let DefaultDownloadBatch = 100
+
+    /// Default batch size for scanning blocks for the compact block processor
+    public static let DefaultScanningBatch = 100
 
     /// Default amount of time, in in seconds, to poll for new blocks. Typically, this should be about half the average
     /// block time.
     public static let defaultPollInterval: TimeInterval = 20
 
     /// Default attempts at retrying.
-    // This has been tweaked in https://github.com/zcash/ZcashLightClientKit/issues/1303
-    // There are many places that rely on hasRetryAttempt() that reads and compares this value.
-    // Better solution is to think about retry logic and potentially either remove completely
-    // or implement more sophisticated solutuion. Until that time, Int.max solves our UX issues
-    // TODO: [#1304] smart retry logic, https://github.com/zcash/ZcashLightClientKit/issues/1304
-    public static let defaultRetries = Int.max
+    public static let defaultRetries: Int = 5
 
     /// The default maximum amount of time to wait during retry backoff intervals. Failed loops will never wait longer than
     /// this before retrying.
@@ -159,13 +161,19 @@ public protocol NetworkConstants {
     /// Default prefix for db filenames
     static var defaultDbNamePrefix: String { get }
 
-    /// Returns the default fee, hardcoded 10k Zatoshi is the minimum ZIP 317 fee
-    static func defaultFee() -> Zatoshi
+    /// fixed height where the SDK considers that the ZIP-321 was deployed. This is a workaround
+    /// for librustzcash not figuring out the tx fee from the tx itself.
+    static var feeChangeHeight: BlockHeight { get }
+
+    /// Returns the default fee according to the blockheight. see [ZIP-313](https://zips.z.cash/zip-0313)
+    static func defaultFee(for height: BlockHeight) -> Zatoshi
 }
 
 public extension NetworkConstants {
-    static func defaultFee() -> Zatoshi {
-        Zatoshi(10_000)
+    static func defaultFee(for height: BlockHeight = BlockHeight.max) -> Zatoshi {
+        guard height >= feeChangeHeight else { return Zatoshi(10_000) }
+
+        return Zatoshi(1_000)
     }
 }
 
@@ -183,6 +191,8 @@ public enum ZcashSDKMainnetConstants: NetworkConstants {
     public static let defaultCacheDbName = "caches.db"
     
     public static let defaultDbNamePrefix = "ZcashSdk_mainnet_"
+    
+    public static let feeChangeHeight: BlockHeight = 1_077_550
 }
 
 public enum ZcashSDKTestnetConstants: NetworkConstants {
@@ -199,4 +209,7 @@ public enum ZcashSDKTestnetConstants: NetworkConstants {
     public static let defaultFsBlockDbRootName = "fs_cache"
     
     public static let defaultDbNamePrefix = "ZcashSdk_testnet_"
+
+    /// Estimated height where wallets are supposed to change the fee
+    public static let feeChangeHeight: BlockHeight = 1_028_500
 }

package/ios/ZCashLightClientKit/DAO/BlockDao.swift

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

@@ -8,22 +8,6 @@
 import Foundation
 import SQLite
 
-extension Connection {
-    public func scalarLocked<V: Value>(_ query: ScalarQuery<V?>) throws -> V.ValueType? {
-        globalDBLock.lock()
-        defer { globalDBLock.unlock() }
-
-        return try scalar(query)
-    }
-    
-    public func scalarLocked<V: Value>(_ query: ScalarQuery<V>) throws -> V {
-        globalDBLock.lock()
-        defer { globalDBLock.unlock() }
-
-        return try scalar(query)
-    }
-}
-
 class TransactionSQLDAO: TransactionRepository {
     enum NotesTableStructure {
         static let transactionID = Expression<Int>("tx")
@@ -32,12 +16,14 @@ class TransactionSQLDAO: TransactionRepository {
 
     let dbProvider: ConnectionProvider
     
+    private let blockDao: BlockSQLDAO
     private let transactionsView = View("v_transactions")
     private let txOutputsView = View("v_tx_outputs")
     private let traceClosure: ((String) -> Void)?
     
     init(dbProvider: ConnectionProvider, traceClosure: ((String) -> Void)? = nil) {
         self.dbProvider = dbProvider
+        self.blockDao = BlockSQLDAO(dbProvider: dbProvider)
         self.traceClosure = traceClosure
     }
 
@@ -51,13 +37,25 @@ class TransactionSQLDAO: TransactionRepository {
         dbProvider.close()
     }
 
+    func blockForHeight(_ height: BlockHeight) async throws -> Block? {
+        try blockDao.block(at: height)
+    }
+
+    func lastScannedHeight() async throws -> BlockHeight {
+        try blockDao.latestBlockHeight()
+    }
+
+    func lastScannedBlock() async throws -> Block? {
+        try blockDao.latestBlock()
+    }
+
     func isInitialized() async throws -> Bool {
         true
     }
     
     func countAll() async throws -> Int {
         do {
-            return try connection().scalarLocked(transactionsView.count)
+            return try connection().scalar(transactionsView.count)
         } catch {
             throw ZcashError.transactionRepositoryCountAll(error)
         }
@@ -65,12 +63,20 @@ class TransactionSQLDAO: TransactionRepository {
     
     func countUnmined() async throws -> Int {
         do {
-            return try connection().scalarLocked(transactionsView.filter(ZcashTransaction.Overview.Column.minedHeight == nil).count)
+            return try connection().scalar(transactionsView.filter(ZcashTransaction.Overview.Column.minedHeight == nil).count)
         } catch {
             throw ZcashError.transactionRepositoryCountUnmined(error)
         }
     }
 
+    func find(id: Int) async throws -> ZcashTransaction.Overview {
+        let query = transactionsView
+            .filter(ZcashTransaction.Overview.Column.id == id)
+            .limit(1)
+
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+    }
+
     func find(rawID: Data) async throws -> ZcashTransaction.Overview {
         let query = transactionsView
             .filter(ZcashTransaction.Overview.Column.rawID == Blob(bytes: rawID.bytes))
@@ -81,7 +87,7 @@ class TransactionSQLDAO: TransactionRepository {
 
     func find(offset: Int, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
         let query = transactionsView
-            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc)
+            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc, ZcashTransaction.Overview.Column.id.desc)
             .filterQueryFor(kind: kind)
             .limit(limit, offset: offset)
 
@@ -90,7 +96,7 @@ class TransactionSQLDAO: TransactionRepository {
 
     func find(in range: CompactBlockRange, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
         let query = transactionsView
-            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc)
+            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc, ZcashTransaction.Overview.Column.id.desc)
             .filter(
                 ZcashTransaction.Overview.Column.minedHeight >= BlockHeight(range.lowerBound) &&
                 ZcashTransaction.Overview.Column.minedHeight <= BlockHeight(range.upperBound)
@@ -103,18 +109,17 @@ class TransactionSQLDAO: TransactionRepository {
 
     func find(from transaction: ZcashTransaction.Overview, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
         guard
-            let transactionBlockHeight = transaction.minedHeight
+            let transactionIndex = transaction.index,
+            let transactionBlockTime = transaction.blockTime
         else { throw ZcashError.transactionRepositoryTransactionMissingRequiredFields }
         
-        let transactionIndex = transaction.index ?? Int.max
         let query = transactionsView
-            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc)
+            .order(
+                (ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc, ZcashTransaction.Overview.Column.id.desc
+            )
             .filter(
-                transactionBlockHeight > ZcashTransaction.Overview.Column.minedHeight
-                || (
-                    transactionBlockHeight == ZcashTransaction.Overview.Column.minedHeight &&
-                    transactionIndex > (ZcashTransaction.Overview.Column.index ?? -1)
-                )
+                Int64(transactionBlockTime) > ZcashTransaction.Overview.Column.blockTime
+                && transactionIndex > ZcashTransaction.Overview.Column.index
             )
             .filterQueryFor(kind: kind)
             .limit(limit)
@@ -125,7 +130,7 @@ class TransactionSQLDAO: TransactionRepository {
     func findReceived(offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview] {
         let query = transactionsView
             .filterQueryFor(kind: .received)
-            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc)
+            .order(ZcashTransaction.Overview.Column.id.desc, (ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc)
             .limit(limit, offset: offset)
 
         return try execute(query) { try ZcashTransaction.Overview(row: $0) }
@@ -134,7 +139,7 @@ class TransactionSQLDAO: TransactionRepository {
     func findSent(offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview] {
         let query = transactionsView
             .filterQueryFor(kind: .sent)
-            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc)
+            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc, ZcashTransaction.Overview.Column.id.desc)
             .limit(limit, offset: offset)
 
         return try execute(query) { try ZcashTransaction.Overview(row: $0) }
@@ -143,7 +148,7 @@ class TransactionSQLDAO: TransactionRepository {
     func findPendingTransactions(latestHeight: BlockHeight, offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview] {
         let query = transactionsView
             .filterPendingFrom(latestHeight)
-            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc)
+            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc, ZcashTransaction.Overview.Column.id.desc)
             .limit(limit, offset: offset)
 
         return try execute(query) { try ZcashTransaction.Overview(row: $0) }
@@ -151,22 +156,22 @@ class TransactionSQLDAO: TransactionRepository {
 
     func findMemos(for transaction: ZcashTransaction.Overview) async throws -> [Memo] {
         do {
-            return try await getTransactionOutputs(for: transaction.rawID)
+            return try await getTransactionOutputs(for: transaction.id)
                 .compactMap { $0.memo }
         } catch {
             throw ZcashError.transactionRepositoryFindMemos(error)
         }
     }
 
-    func getTransactionOutputs(for rawID: Data) async throws -> [ZcashTransaction.Output] {
+    func getTransactionOutputs(for id: Int) async throws -> [ZcashTransaction.Output] {
         let query = self.txOutputsView
-            .filter(ZcashTransaction.Output.Column.rawID == Blob(bytes: rawID.bytes))
+            .filter(ZcashTransaction.Output.Column.idTx == id)
 
         return try execute(query) { try ZcashTransaction.Output(row: $0) }
     }
 
-    func getRecipients(for rawID: Data) async throws -> [TransactionRecipient] {
-        try await getTransactionOutputs(for: rawID).map { $0.recipient }
+    func getRecipients(for id: Int) async throws -> [TransactionRecipient] {
+        try await getTransactionOutputs(for: id).map { $0.recipient }
     }
 
     private func execute<Entity>(_ query: View, createEntity: (Row) throws -> Entity) throws -> Entity {
@@ -176,14 +181,11 @@ class TransactionSQLDAO: TransactionRepository {
     }
 
     private func execute<Entity>(_ query: View, createEntity: (Row) throws -> Entity) throws -> [Entity] {
-        globalDBLock.lock()
-        defer { globalDBLock.unlock() }
-        
         do {
             let entities = try connection()
                 .prepare(query)
                 .map(createEntity)
-
+            
             return entities
         } catch {
             if let error = error as? ZcashError {

package/ios/ZCashLightClientKit/DAO/UnspentTransactionOutputDao.swift

@@ -109,9 +109,6 @@ class UnspentTransactionOutputSQLDAO: UnspentTransactionOutputRepository {
             )
             """
         do {
-            globalDBLock.lock()
-            defer { globalDBLock.unlock() }
-            
             try dbProvider.connection().run(stringStatement)
         } catch {
             throw ZcashError.unspentTransactionOutputDAOCreateTable(error)
@@ -121,11 +118,8 @@ class UnspentTransactionOutputSQLDAO: UnspentTransactionOutputRepository {
     /// - Throws: `unspentTransactionOutputDAOStore` if sqlite query fails.
     func store(utxos: [UnspentTransactionOutputEntity]) async throws {
         do {
-            globalDBLock.lock()
-            defer { globalDBLock.unlock() }
-
             let db = try dbProvider.connection()
-            try db.transaction {
+            try dbProvider.connection().transaction {
                 for utxo in utxos.map({ $0 as? UTXO ?? $0.asUTXO() }) {
                     try db.run(table.insert(utxo))
                 }
@@ -138,9 +132,6 @@ class UnspentTransactionOutputSQLDAO: UnspentTransactionOutputRepository {
     /// - Throws: `unspentTransactionOutputDAOClearAll` if sqlite query fails.
     func clearAll(address: String?) async throws {
         do {
-            globalDBLock.lock()
-            defer { globalDBLock.unlock() }
-
             if let tAddr = address {
                 try dbProvider.connection().run(table.filter(TableColumns.address == tAddr).delete())
             } else {
@@ -187,16 +178,16 @@ class UnspentTransactionOutputSQLDAO: UnspentTransactionOutputRepository {
     /// - Throws: `unspentTransactionOutputDAOBalance` if sqlite query fails.
     func balance(address: String, latestHeight: BlockHeight) async throws -> WalletBalance {
         do {
-            let verified = try dbProvider.connection().scalarLocked(
+            let verified = try dbProvider.connection().scalar(
                 table.select(TableColumns.valueZat.sum)
                     .filter(TableColumns.address == address)
                     .filter(TableColumns.height <= latestHeight - ZcashSDK.defaultStaleTolerance)
             ) ?? 0
-            let total = try dbProvider.connection().scalarLocked(
+            let total = try dbProvider.connection().scalar(
                 table.select(TableColumns.valueZat.sum)
                     .filter(TableColumns.address == address)
             ) ?? 0
-
+            
             return WalletBalance(
                 verified: Zatoshi(Int64(verified)),
                 total: Zatoshi(Int64(total))

package/ios/ZCashLightClientKit/Entity/AccountEntity.swift

@@ -66,9 +66,6 @@ class AccountSQDAO: AccountRepository {
     ///     - `accountDAOGetAll` if sqlite query fetching account data failed.
     func getAll() throws -> [AccountEntity] {
         do {
-            globalDBLock.lock()
-            defer { globalDBLock.unlock() }
-            
             return try dbProvider.connection()
                 .prepare(table)
                 .map { row -> DbAccount in
@@ -93,9 +90,6 @@ class AccountSQDAO: AccountRepository {
     func findBy(account: Int) throws -> AccountEntity? {
         let query = table.filter(TableColums.account == account).limit(1)
         do {
-            globalDBLock.lock()
-            defer { globalDBLock.unlock() }
-
             return try dbProvider.connection()
                 .prepare(query)
                 .map {
@@ -125,9 +119,6 @@ class AccountSQDAO: AccountRepository {
 
         let updatedRows: Int
         do {
-            globalDBLock.lock()
-            defer { globalDBLock.unlock() }
-
             updatedRows = try dbProvider.connection().run(table.filter(TableColums.account == acc.account).update(acc))
         } catch {
             throw ZcashError.accountDAOUpdate(error)

package/ios/ZCashLightClientKit/Entity/BlockProgress.swift

@@ -0,0 +1,24 @@
+//
+//  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)
+}

package/ios/ZCashLightClientKit/Entity/TransactionEntity.swift

@@ -25,9 +25,9 @@ public enum ZcashTransaction {
             init(
                 currentHeight: BlockHeight,
                 minedHeight: BlockHeight?,
-                expiredUnmined: Bool?
+                expiredUnmined: Bool
             ) {
-                guard let expiredUnmined, !expiredUnmined else {
+                guard !expiredUnmined else {
                     self = .expired
                     return
                 }
@@ -48,6 +48,7 @@ public enum ZcashTransaction {
         public let blockTime: TimeInterval?
         public let expiryHeight: BlockHeight?
         public let fee: Zatoshi?
+        public let id: Int
         public let index: Int?
         public var isSentTransaction: Bool { value < Zatoshi(0) }
         public let hasChange: Bool
@@ -58,7 +59,7 @@ public enum ZcashTransaction {
         public let receivedNoteCount: Int
         public let sentNoteCount: Int
         public let value: Zatoshi
-        public let isExpiredUmined: Bool?
+        public let isExpiredUmined: Bool
     }
 
     public struct Output {
@@ -78,7 +79,7 @@ public enum ZcashTransaction {
             }
         }
 
-        public let rawID: Data
+        public let idTx: Int
         public let pool: Pool
         public let index: Int
         public let fromAccount: Int?
@@ -98,7 +99,7 @@ public enum ZcashTransaction {
 
 extension ZcashTransaction.Output {
     enum Column {
-        static let rawID = Expression<Blob>("txid")
+        static let idTx = Expression<Int>("id_tx")
         static let pool = Expression<Int>("output_pool")
         static let index = Expression<Int>("output_index")
         static let toAccount = Expression<Int?>("to_account")
@@ -111,7 +112,7 @@ extension ZcashTransaction.Output {
 
     init(row: Row) throws {
         do {
-            rawID = Data(blob: try row.get(Column.rawID))
+            idTx = try row.get(Column.idTx)
             pool = .init(rawValue: try row.get(Column.pool))
             index = try row.get(Column.index)
             fromAccount = try row.get(Column.fromAccount)
@@ -143,6 +144,7 @@ extension ZcashTransaction.Output {
 extension ZcashTransaction.Overview {
     enum Column {
         static let accountId = Expression<Int>("account_id")
+        static let id = Expression<Int>("id_tx")
         static let minedHeight = Expression<BlockHeight?>("mined_height")
         static let index = Expression<Int?>("tx_index")
         static let rawID = Expression<Blob>("txid")
@@ -155,13 +157,14 @@ extension ZcashTransaction.Overview {
         static let receivedNoteCount = Expression<Int>("received_note_count")
         static let memoCount = Expression<Int>("memo_count")
         static let blockTime = Expression<Int64?>("block_time")
-        static let expiredUnmined = Expression<Bool?>("expired_unmined")
+        static let expiredUnmined = Expression<Bool>("expired_unmined")
     }
 
     init(row: Row) throws {
         do {
             self.accountId = try row.get(Column.accountId)
             self.expiryHeight = try row.get(Column.expiryHeight)
+            self.id = try row.get(Column.id)
             self.index = try row.get(Column.index)
             self.hasChange = try row.get(Column.hasChange)
             self.memoCount = try row.get(Column.memoCount)