react-native-zcash 0.3.4 → 0.4.0

package/ios/ZCashLightClientKit/Constants/ZcashSDK.swift

@@ -0,0 +1,215 @@
+//
+//  ZcashSDK.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 7/22/21.
+//
+
+import Foundation
+public protocol ZcashNetwork {
+    var networkType: NetworkType { get }
+    var constants: NetworkConstants.Type { get }
+}
+
+public enum NetworkType {
+    case mainnet
+    case testnet
+    
+    var networkId: UInt32 {
+        switch self {
+        case .mainnet:  return 1
+        case .testnet:  return 0
+        }
+    }
+}
+
+extension NetworkType {
+    static func forChainName(_ chainame: String) -> NetworkType? {
+        switch chainame {
+        case "test":    return .testnet
+        case "main":    return .mainnet
+        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 {
+    public static func network(for networkType: NetworkType) -> ZcashNetwork {
+        switch networkType {
+        case .mainnet:  return ZcashMainnet()
+        case .testnet:  return ZcashTestnet()
+        }
+    }
+}
+
+class ZcashTestnet: ZcashNetwork {
+    let networkType: NetworkType = .testnet
+    let constants: NetworkConstants.Type = ZcashSDKTestnetConstants.self
+}
+
+class ZcashMainnet: ZcashNetwork {
+    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 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.
+    static var saplingActivationHeight: BlockHeight { get }
+
+    /// Default Name for LibRustZcash data.db
+    static var defaultDataDbName: String { get }
+
+    static var defaultFsBlockDbRootName: 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.
+    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(for height: BlockHeight = BlockHeight.max) -> Zatoshi {
+        guard height >= feeChangeHeight else { return Zatoshi(10_000) }
+
+        return Zatoshi(1_000)
+    }
+}
+
+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 let defaultDbNamePrefix = "ZcashSdk_mainnet_"
+    
+    public static let feeChangeHeight: BlockHeight = 1_077_550
+}
+
+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"
+    
+    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/PagedTransactionDao.swift

@@ -0,0 +1,54 @@
+//
+//  PagedTransactionDAO.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 12/9/19.
+//
+
+import Foundation
+
+class PagedTransactionDAO: PaginatedTransactionRepository {
+    let pageSize: Int
+    let transactionRepository: TransactionRepository
+    let kind: TransactionKind
+    
+    var pageCount: Int {
+        get async {
+            guard pageSize > 0 else {
+                return 0
+            }
+            return await itemCount / pageSize
+        }
+    }
+    
+    var itemCount: Int {
+        get async {
+            guard let count = try? await transactionRepository.countAll() else {
+                return 0
+            }
+            return count
+        }
+    }
+    
+    init(repository: TransactionRepository, pageSize: Int = 30, kind: TransactionKind = .all) {
+        self.transactionRepository = repository
+        self.pageSize = pageSize
+        self.kind = kind
+    }
+    
+    func page(_ number: Int) async throws -> [ZcashTransaction.Overview]? {
+        let offset = number * pageSize
+        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<[ZcashTransaction.Overview]?, Error>) -> Void) {
+        Task(priority: .userInitiated) {
+            do {
+                result(.success(try await self.page(number)))
+            } catch {
+                result(.failure(error))
+            }
+        }
+    }
+}

package/ios/ZCashLightClientKit/DAO/TransactionDao.swift

@@ -0,0 +1,245 @@
+//
+//  TransactionDao.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/15/19.
+//
+
+import Foundation
+import SQLite
+
+class TransactionSQLDAO: TransactionRepository {
+    enum NotesTableStructure {
+        static let transactionID = Expression<Int>("tx")
+        static let memo = Expression<Blob>("memo")
+    }
+
+    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
+    }
+
+    private func connection() throws -> Connection {
+        let conn = try dbProvider.connection()
+        conn.trace(traceClosure)
+        return conn
+    }
+
+    func closeDBConnection() {
+        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().scalar(transactionsView.count)
+        } catch {
+            throw ZcashError.transactionRepositoryCountAll(error)
+        }
+    }
+    
+    func countUnmined() async throws -> Int {
+        do {
+            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))
+            .limit(1)
+
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+    }
+
+    func find(offset: Int, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
+        let query = transactionsView
+            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc, ZcashTransaction.Overview.Column.id.desc)
+            .filterQueryFor(kind: kind)
+            .limit(limit, offset: offset)
+
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+    }
+
+    func find(in range: CompactBlockRange, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
+        let query = transactionsView
+            .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)
+            )
+            .filterQueryFor(kind: kind)
+            .limit(limit)
+
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+    }
+
+    func find(from transaction: ZcashTransaction.Overview, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
+        guard
+            let transactionIndex = transaction.index,
+            let transactionBlockTime = transaction.blockTime
+        else { throw ZcashError.transactionRepositoryTransactionMissingRequiredFields }
+        
+        let query = transactionsView
+            .order(
+                (ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc, ZcashTransaction.Overview.Column.id.desc
+            )
+            .filter(
+                Int64(transactionBlockTime) > ZcashTransaction.Overview.Column.blockTime
+                && transactionIndex > ZcashTransaction.Overview.Column.index
+            )
+            .filterQueryFor(kind: kind)
+            .limit(limit)
+        
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+    }
+
+    func findReceived(offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview] {
+        let query = transactionsView
+            .filterQueryFor(kind: .received)
+            .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) }
+    }
+
+    func findSent(offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview] {
+        let query = transactionsView
+            .filterQueryFor(kind: .sent)
+            .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) }
+    }
+
+    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, ZcashTransaction.Overview.Column.id.desc)
+            .limit(limit, offset: offset)
+
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+    }
+
+    func findMemos(for transaction: ZcashTransaction.Overview) async throws -> [Memo] {
+        do {
+            return try await getTransactionOutputs(for: transaction.id)
+                .compactMap { $0.memo }
+        } catch {
+            throw ZcashError.transactionRepositoryFindMemos(error)
+        }
+    }
+
+    func getTransactionOutputs(for id: Int) async throws -> [ZcashTransaction.Output] {
+        let query = self.txOutputsView
+            .filter(ZcashTransaction.Output.Column.idTx == id)
+
+        return try execute(query) { try ZcashTransaction.Output(row: $0) }
+    }
+
+    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 {
+        let entities: [Entity] = try execute(query, createEntity: createEntity)
+        guard let entity = entities.first else { throw ZcashError.transactionRepositoryEntityNotFound }
+        return entity
+    }
+
+    private func execute<Entity>(_ query: View, createEntity: (Row) throws -> Entity) throws -> [Entity] {
+        do {
+            let entities = try connection()
+                .prepare(query)
+                .map(createEntity)
+            
+            return entities
+        } catch {
+            if let error = error as? ZcashError {
+                throw error
+            } else {
+                throw ZcashError.transactionRepositoryQueryExecute(error)
+            }
+        }
+    }
+}
+
+private extension View {
+    func filterPendingFrom(_ latestHeight: BlockHeight) -> View {
+        filter(
+            // transaction has not expired
+            ZcashTransaction.Overview.Column.expiredUnmined == false &&
+            // transaction is "sent"
+            ZcashTransaction.Overview.Column.value < 0 &&
+            // transaction has not been mined yet OR
+            // it has been within the latest `defaultStaleTolerance` blocks
+            (
+                ZcashTransaction.Overview.Column.minedHeight == nil ||
+                ZcashTransaction.Overview.Column.minedHeight > (latestHeight - ZcashSDK.defaultStaleTolerance)
+            )
+        )
+    }
+}
+
+private extension View {
+    func filterQueryFor(kind: TransactionKind) -> View {
+        switch kind {
+        case .all:
+            return self
+        case .sent:
+            return filter(ZcashTransaction.Overview.Column.value < 0)
+        case .received:
+            return filter(ZcashTransaction.Overview.Column.value >= 0)
+        }
+    }
+}
+
+extension Data {
+    init(blob: SQLite.Blob) {
+        let bytes = blob.bytes
+        self = Data(bytes: bytes, count: bytes.count)
+    }
+    
+    var bytes: [UInt8] {
+        return [UInt8](self)
+    }
+}
+
+extension Array where Element == UInt8 {
+    var data: Data {
+        return Data(self)
+    }
+}