react-native-zcash 0.3.5 → 0.4.0

package/ios/ZCashLightClientKit/Constants/ZcashSDK.swift

@@ -31,6 +31,25 @@ extension NetworkType {
         default:        return nil
         }
     }
+    
+    static func forNetworkId(_ id: UInt32) -> NetworkType? {
+        switch id {
+        case 1: return .mainnet
+        case 0: return .testnet
+        default: return nil
+        }
+    }
+}
+
+extension NetworkType {
+    public var chainName: String {
+        switch self {
+        case .mainnet:
+            return "main"
+        case .testnet:
+            return "test"
+        }
+    }
 }
 
 public enum ZcashNetworkBuilder {
@@ -43,203 +62,154 @@ public enum ZcashNetworkBuilder {
 }
 
 class ZcashTestnet: ZcashNetwork {
-    var networkType: NetworkType = .testnet
-    var constants: NetworkConstants.Type = ZcashSDKTestnetConstants.self
+    let networkType: NetworkType = .testnet
+    let constants: NetworkConstants.Type = ZcashSDKTestnetConstants.self
 }
 
 class ZcashMainnet: ZcashNetwork {
-    var networkType: NetworkType = .mainnet
-    var constants: NetworkConstants.Type = ZcashSDKMainnetConstants.self
+    let networkType: NetworkType = .mainnet
+    let constants: NetworkConstants.Type = ZcashSDKMainnetConstants.self
 }
 
 /**
 Constants of ZcashLightClientKit. this constants don't
 */
 public enum ZcashSDK {
-    /**
-    The number of zatoshi that equal 1 ZEC.
-    */
-    public static var zatoshiPerZEC: BlockHeight = 100_000_000
-    
-    /**
-    The theoretical maximum number of blocks in a reorg, due to other bottlenecks in the protocol design.
-    */
-    public static var maxReorgSize = 100
-
-    /**
-    The amount of blocks ahead of the current height where new transactions are set to expire. This value is controlled
-    by the rust backend but it is helpful to know what it is set to and should be kept in sync.
-    */
-    public static var expiryOffset = 20
-
-    //
-    // Defaults
-    //
-    /**
-    Default size of batches of blocks to request from the compact block service.
-    */
-    public static var DefaultBatchSize = 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 var defaultPollInterval: TimeInterval = 20
-
-    /**
-    Default attempts at retrying.
-    */
-    public static var defaultRetries: Int = 5
-
-    /**
-    The default maximum amount of time to wait during retry backoff intervals. Failed loops will never wait longer than
-    this before retyring.
-    */
-    public static var defaultMaxBackOffInterval: TimeInterval = 600
-
-    /**
-    Default number of blocks to rewind when a chain reorg is detected. This should be large enough to recover from the
-    reorg but smaller than the theoretical max reorg size of 100.
-    */
-    public static var defaultRewindDistance: Int = 10
-
-    /**
-    The number of blocks to allow before considering our data to be stale. This usually helps with what to do when
-    returning from the background and is exposed via the Synchronizer's isStale function.
-    */
-    public static var defaultStaleTolerance: Int = 10
-    
-    /**
-    Default Name for LibRustZcash data.db
-    */
-    public static var defaultDataDbName = "data.db"
-    
-    /**
-    Default Name for Compact Block caches db
-    */
-    public static var defaultCacheDbName = "caches.db"
-
-    /**
-    Default name for pending transactions db
-    */
-    public static var defaultPendingDbName = "pending.db"
-    
-    /**
-    File name for the sapling spend params
-    */
-    public static var spendParamFilename = "sapling-spend.params"
-
-    /**
-    File name for the sapling output params
-    */
-    public static var outputParamFilename = "sapling-output.params"
-
-    /**
-    The Url that is used by default in zcashd.
-    We'll want to make this externally configurable, rather than baking it into the SDK but
-    this will do for now, since we're using a cloudfront URL that already redirects.
-    */
-    public static var cloudParameterURL = "https://z.cash/downloads/"
+    /// The number of zatoshi that equal 1 ZEC.
+    public static let zatoshiPerZEC: BlockHeight = 100_000_000
+
+    /// The theoretical maximum number of blocks in a reorg, due to other bottlenecks in the protocol design.
+    public static let maxReorgSize = 100
+
+    /// The amount of blocks ahead of the current height where new transactions are set to expire. This value is controlled
+    /// by the rust backend but it is helpful to know what it is set to and should be kept in sync.
+    public static let expiryOffset = 20
+
+    // 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 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.
+    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.
+    public static let defaultMaxBackOffInterval: TimeInterval = 600
+
+    /// Default number of blocks to rewind when a chain reorg is detected. This should be large enough to recover from the
+    /// reorg but smaller than the theoretical max reorg size of 100.
+    public static let defaultRewindDistance: Int = 10
+
+    /// The number of blocks to allow before considering our data to be stale. This usually helps with what to do when
+    /// returning from the background and is exposed via the Synchronizer's isStale function.
+    public static let defaultStaleTolerance: Int = 10
+
+    /// Default Name for LibRustZcash data.db
+    public static let defaultDataDbName = "data.db"
+
+    /// Default Name for Compact Block file system based db
+    public static let defaultFsCacheName = "fs_cache"
+
+    /// Default Name for Compact Block caches db
+    public static let defaultCacheDbName = "caches.db"
+
+    /// The Url that is used by default in zcashd.
+    /// We'll want to make this externally configurable, rather than baking it into the SDK but
+    /// this will do for now, since we're using a cloudfront URL that already redirects.
+    public static let cloudParameterURL = "https://z.cash/downloads/"
+
+    /// File name for the sapling spend params
+    public static let spendParamFilename = "sapling-spend.params"
+    // swiftlint:disable:next force_unwrapping
+    public static let spendParamFileURL = URL(string: cloudParameterURL)!.appendingPathComponent(spendParamFilename)
+
+    /// File name for the sapling output params
+    public static let outputParamFilename = "sapling-output.params"
+    // swiftlint:disable:next force_unwrapping
+    public static let outputParamFileURL = URL(string: cloudParameterURL)!.appendingPathComponent(outputParamFilename)
 }
 
 public protocol NetworkConstants {
-    /**
-    The height of the first sapling block. When it comes to shielded transactions, we do not need to consider any blocks
-    prior to this height, at all.
-    */
+    /// The height of the first sapling block. When it comes to shielded transactions, we do not need to consider any blocks
+    /// prior to this height, at all.
     static var saplingActivationHeight: BlockHeight { get }
-    
-    /**
-    Default Name for LibRustZcash data.db
-    */
+
+    /// Default Name for LibRustZcash data.db
     static var defaultDataDbName: String { get }
 
-    /**
-    Default Name for Compact Block caches db
-    */
-    static var defaultCacheDbName: String { get }
+    static var defaultFsBlockDbRootName: String { get }
 
-    /**
-    Default name for pending transactions db
-    */
-    static var defaultPendingDbName: String { get }
+    /// Default Name for Compact Block caches db
+    @available(*, deprecated, message: "use this name to clean up the sqlite compact block database")
+    static var defaultCacheDbName: String { get }
 
+    /// Default prefix for db filenames
     static var defaultDbNamePrefix: String { get }
-   
-    /**
-    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.
-    */
+
+    /// 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 }
-    
-    static func defaultFee(for height: BlockHeight) -> Int64
+
+    /// 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(for height: BlockHeight = BlockHeight.max) -> Int64 {
-        guard  height >= feeChangeHeight else { return 10_000 }
-        
-        return 1_000
+    static func defaultFee(for height: BlockHeight = BlockHeight.max) -> Zatoshi {
+        guard height >= feeChangeHeight else { return Zatoshi(10_000) }
+
+        return Zatoshi(1_000)
     }
 }
 
-public class ZcashSDKMainnetConstants: NetworkConstants {
-    private init() {}
-    
-    /**
-    The height of the first sapling block. When it comes to shielded transactions, we do not need to consider any blocks
-    prior to this height, at all.
-    */
-    public static var saplingActivationHeight: BlockHeight = 419_200
-    
-    /**
-    Default Name for LibRustZcash data.db
-    */
-    public static var defaultDataDbName = "data.db"
-
-    /**
-    Default Name for Compact Block caches db
-    */
-    public static var defaultCacheDbName = "caches.db"
-
-    /**
-    Default name for pending transactions db
-    */
-    public static var defaultPendingDbName = "pending.db"
+public enum ZcashSDKMainnetConstants: NetworkConstants {
+    /// The height of the first sapling block. When it comes to shielded transactions, we do not need to consider any blocks
+    /// prior to this height, at all.
+    public static let saplingActivationHeight: BlockHeight = 419_200
+
+    /// Default Name for LibRustZcash data.db
+    public static let defaultDataDbName = "data.db"
+
+    public static let defaultFsBlockDbRootName = "fs_cache"
+
+    /// Default Name for Compact Block caches db
+    public static let defaultCacheDbName = "caches.db"
     
-    public static var defaultDbNamePrefix = "ZcashSdk_mainnet_"
+    public static let defaultDbNamePrefix = "ZcashSdk_mainnet_"
     
-    public static var feeChangeHeight: BlockHeight = 1_077_550
+    public static let feeChangeHeight: BlockHeight = 1_077_550
 }
 
-public class ZcashSDKTestnetConstants: NetworkConstants {
-    private init() {}
-   
-    /**
-    The height of the first sapling block. When it comes to shielded transactions, we do not need to consider any blocks
-    prior to this height, at all.
-    */
-    public static var saplingActivationHeight: BlockHeight = 280_000
-   
-    /**
-    Default Name for LibRustZcash data.db
-    */
-    public static var defaultDataDbName = "data.db"
-
-    /**
-    Default Name for Compact Block caches db
-    */
-    public static var defaultCacheDbName = "caches.db"
-
-    /**
-    Default name for pending transactions db
-    */
-    public static var defaultPendingDbName = "pending.db"
-    
-    public static var defaultDbNamePrefix = "ZcashSdk_testnet_"
+public enum ZcashSDKTestnetConstants: NetworkConstants {
+    /// The height of the first sapling block. When it comes to shielded transactions, we do not need to consider any blocks
+    /// prior to this height, at all.
+    public static let saplingActivationHeight: BlockHeight = 280_000
+
+    /// Default Name for LibRustZcash data.db
+    public static let defaultDataDbName = "data.db"
+
+    /// Default Name for Compact Block caches db
+    public static let defaultCacheDbName = "caches.db"
+
+    public static let defaultFsBlockDbRootName = "fs_cache"
     
-    /**
-    Estimated height where wallets are supposed to change the fee
-    */
-    public static var feeChangeHeight: BlockHeight = 1_028_500
+    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

@@ -11,6 +11,7 @@ import SQLite
 
 protocol BlockDao {
     func latestBlockHeight() throws -> BlockHeight
+    func latestBlock() throws -> Block?
     func block(at height: BlockHeight) throws -> Block?
 }
 
@@ -23,40 +24,84 @@ struct Block: Codable {
     }
 
     enum TableStructure {
-        static var height = Expression<Int>(Block.CodingKeys.height.rawValue)
-        static var hash = Expression<Blob>(Block.CodingKeys.hash.rawValue)
-        static var time = Expression<Int>(Block.CodingKeys.time.rawValue)
-        static var saplingTree = Expression<Blob>(Block.CodingKeys.saplingTree.rawValue)
+        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)
     }
 
-    var height: BlockHeight
-    var hash: Data
-    var time: Int
-    var saplingTree: Data
+    let height: BlockHeight
+    let hash: Data
+    let time: Int
+    let saplingTree: Data
     
-    static var table = Table("blocks")
+    static let table = Table("blocks")
 }
 
 class BlockSQLDAO: BlockDao {
-    var dbProvider: ConnectionProvider
-    var table: Table
-    var height = Expression<Int>("height")
-    
+    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? {
-        try dbProvider
-            .connection()
-            .prepare(Block.table.filter(Block.TableStructure.height == height).limit(1))
-            .map({ try $0.decode() })
-            .first
+        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 {
-        try dbProvider.connection().scalar(table.select(height.max)) ?? BlockHeight.empty()
+        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)
+            }
+        }
     }
 }
 

package/ios/ZCashLightClientKit/DAO/PagedTransactionDao.swift

@@ -1,5 +1,5 @@
 //
-//  File.swift
+//  PagedTransactionDAO.swift
 //  ZcashLightClientKit
 //
 //  Created by Francisco Gindre on 12/9/19.
@@ -8,22 +8,26 @@
 import Foundation
 
 class PagedTransactionDAO: PaginatedTransactionRepository {
-    var pageSize: Int
-    var transactionRepository: TransactionRepository
-    var kind: TransactionKind
+    let pageSize: Int
+    let transactionRepository: TransactionRepository
+    let kind: TransactionKind
     
     var pageCount: Int {
-        guard pageSize > 0 else {
-            return 0
+        get async {
+            guard pageSize > 0 else {
+                return 0
+            }
+            return await itemCount / pageSize
         }
-        return itemCount / pageSize
     }
     
     var itemCount: Int {
-        guard let count = try? transactionRepository.countAll() else {
-            return 0
+        get async {
+            guard let count = try? await transactionRepository.countAll() else {
+                return 0
+            }
+            return count
         }
-        return count
     }
     
     init(repository: TransactionRepository, pageSize: Int = 30, kind: TransactionKind = .all) {
@@ -32,28 +36,16 @@ class PagedTransactionDAO: PaginatedTransactionRepository {
         self.kind = kind
     }
     
-    func getAll(offset: Int, limit: Int, kind: TransactionKind) throws -> [ConfirmedTransactionEntity]? {
-        switch kind {
-        case .all:
-            return try transactionRepository.findAll(offset: offset, limit: limit)
-        case .received:
-            return try transactionRepository.findAll(offset: offset, limit: limit)
-        case .sent:
-            return try transactionRepository.findAllSentTransactions(offset: offset, limit: limit)
-        }
-    }
-    
-    func page(_ number: Int) throws -> [TransactionEntity]? {
+    func page(_ number: Int) async throws -> [ZcashTransaction.Overview]? {
         let offset = number * pageSize
-        guard offset < itemCount else { return nil }
-        return try getAll(offset: offset, limit: pageSize, kind: kind)?.map({ $0.transactionEntity })
+        guard offset < (await itemCount) else { return nil }
+        return try await transactionRepository.find(offset: offset, limit: pageSize, kind: kind)
     }
     
-    func page(_ number: Int, result: @escaping (Result<[TransactionEntity]?, Error>) -> Void) {
-        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
-            guard let self = self else { return }
+    func page(_ number: Int, result: @escaping (Result<[ZcashTransaction.Overview]?, Error>) -> Void) {
+        Task(priority: .userInitiated) {
             do {
-                result(.success(try self.page(number)))
+                result(.success(try await self.page(number)))
             } catch {
                 result(.failure(error))
             }