react-native-zcash 0.3.4 → 0.3.5

package/ios/ZCashLightClientKit/Constants/ZcashSDK.swift

@@ -0,0 +1,245 @@
+//
+//  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
+        }
+    }
+}
+
+public enum ZcashNetworkBuilder {
+    public static func network(for networkType: NetworkType) -> ZcashNetwork {
+        switch networkType {
+        case .mainnet:  return ZcashMainnet()
+        case .testnet:  return ZcashTestnet()
+        }
+    }
+}
+
+class ZcashTestnet: ZcashNetwork {
+    var networkType: NetworkType = .testnet
+    var constants: NetworkConstants.Type = ZcashSDKTestnetConstants.self
+}
+
+class ZcashMainnet: ZcashNetwork {
+    var networkType: NetworkType = .mainnet
+    var 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/"
+}
+
+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 }
+
+    /**
+    Default Name for Compact Block caches db
+    */
+    static var defaultCacheDbName: String { get }
+
+    /**
+    Default name for pending transactions db
+    */
+    static var defaultPendingDbName: String { get }
+
+    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 }
+    
+    static func defaultFee(for height: BlockHeight) -> Int64
+}
+
+public extension NetworkConstants {
+    static func defaultFee(for height: BlockHeight = BlockHeight.max) -> Int64 {
+        guard  height >= feeChangeHeight else { return 10_000 }
+        
+        return 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 static var defaultDbNamePrefix = "ZcashSdk_mainnet_"
+    
+    public static var 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_"
+    
+    /**
+    Estimated height where wallets are supposed to change the fee
+    */
+    public static var feeChangeHeight: BlockHeight = 1_028_500
+}

package/ios/ZCashLightClientKit/DAO/BlockDao.swift

@@ -0,0 +1,67 @@
+//
+//  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 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 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)
+    }
+
+    var height: BlockHeight
+    var hash: Data
+    var time: Int
+    var saplingTree: Data
+    
+    static var table = Table("blocks")
+}
+
+class BlockSQLDAO: BlockDao {
+    var dbProvider: ConnectionProvider
+    var table: Table
+    var height = Expression<Int>("height")
+    
+    init(dbProvider: ConnectionProvider) {
+        self.dbProvider = dbProvider
+        self.table = Table("Blocks")
+    }
+
+    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
+    }
+    
+    func latestBlockHeight() throws -> BlockHeight {
+        try dbProvider.connection().scalar(table.select(height.max)) ?? BlockHeight.empty()
+    }
+}
+
+extension BlockSQLDAO: BlockRepository {
+    func lastScannedBlockHeight() -> BlockHeight {
+        (try? self.latestBlockHeight()) ?? BlockHeight.empty()
+    }
+}

package/ios/ZCashLightClientKit/DAO/CompactBlockDAO.swift

@@ -0,0 +1,24 @@
+//
+//   CompactBlockDAO.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/16/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+protocol CompactBlockDAO {
+    func createTable() throws
+    
+    func insert(_ block: ZcashCompactBlock) throws
+    
+    func insert(_ blocks: [ZcashCompactBlock]) throws
+    
+    /**
+    Query the latest block height, returns -1 if no block is stored
+    */
+    func latestBlockHeight() throws -> BlockHeight
+    
+    func rewind(to height: BlockHeight) throws
+}

package/ios/ZCashLightClientKit/DAO/NotesDao.swift

@@ -0,0 +1,142 @@
+//
+//  NotesDao.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/18/19.
+//
+
+import Foundation
+import SQLite
+
+struct ReceivedNote: ReceivedNoteEntity, Codable {
+    enum CodingKeys: String, CodingKey {
+        case id = "id_note"
+        case diversifier
+        case rcm
+        case nf
+        case isChange = "is_change"
+        case transactionId = "id_tx"
+        case outputIndex = "output_index"
+        case account
+        case value
+        case memo
+        case spent
+    }
+    var id: Int
+    var diversifier: Data
+    var rcm: Data
+    var nf: Data
+    var isChange: Bool
+    var transactionId: Int
+    var outputIndex: Int
+    var account: Int
+    var value: Int
+    var memo: Data?
+    var spent: Int?
+}
+
+class ReceivedNotesSQLDAO: ReceivedNoteRepository {
+    let table = Table("received_notes")
+
+    var dbProvider: ConnectionProvider
+    
+    init(dbProvider: ConnectionProvider) {
+        self.dbProvider = dbProvider
+    }
+    
+    func count() throws -> Int {
+        try dbProvider.connection().scalar(table.count)
+    }
+    
+    func receivedNote(byRawTransactionId: Data) throws -> ReceivedNoteEntity? {
+        let transactions = Table("transactions")
+        let idTx = Expression<Int>("id_tx")
+        let transaction = Expression<Int>("tx")
+        let txid = Expression<Blob>("txid")
+        let joinStatement = table
+            .join(
+                .inner,
+                transactions,
+                on: transactions[idTx] == table[transaction]
+            )
+            .where(transactions[txid] == Blob(bytes: byRawTransactionId.bytes))
+            .limit(1)
+        
+        return try dbProvider.connection()
+            .prepare(joinStatement)
+            .map { row -> ReceivedNote in
+                try row.decode()
+            }
+            .first
+    }
+}
+
+struct SentNote: SentNoteEntity, Codable {
+    enum CodingKeys: String, CodingKey {
+        case id = "id_note"
+        case transactionId = "tx"
+        case outputIndex = "output_index"
+        case account = "from_account"
+        case address
+        case value
+        case memo
+    }
+    
+    var id: Int
+    var transactionId: Int
+    var outputIndex: Int
+    var account: Int
+    var address: String
+    var value: Int
+    var memo: Data?
+}
+
+class SentNotesSQLDAO: SentNotesRepository {
+    let table = Table("sent_notes")
+
+    var dbProvider: ConnectionProvider
+    
+    init(dbProvider: ConnectionProvider) {
+        self.dbProvider = dbProvider
+    }
+    
+    func count() throws -> Int {
+        try dbProvider.connection().scalar(table.count)
+    }
+    
+    func sentNote(byRawTransactionId: Data) throws -> SentNoteEntity? {
+        let transactions = Table("transactions")
+        let idTx = Expression<Int>("id_tx")
+        let transaction = Expression<Int>("tx")
+        let txid = Expression<Blob>("txid")
+        let joinStatement = table
+            .join(
+                .inner,
+                transactions,
+                on: transactions[idTx] == table[transaction]
+            )
+            .where(transactions[txid] == Blob(bytes: byRawTransactionId.bytes))
+            .limit(1)
+
+        return try dbProvider.connection()
+            .prepare(joinStatement)
+            .map { row -> SentNote in
+                try row.decode()
+            }
+            .first
+        //        try dbProvider.connection().run("""
+        //            SELECT sent_notes.id_note as id,
+        //                sent_notes.tx as transactionId,
+//                sent_notes.output_index as outputIndex,
+//                sent_notes.account as account,
+//                sent_notes.address as address,
+//                sent_notes.value as value,
+//                sent_notes.memo as memo
+//            FROM sent_note JOIN transactions
+//            WHERE sent_note.tx = transactions.id_tx AND
+//                    transactions.txid = \(Blob(bytes: byRawTransactionId.bytes))
+//            """).map({ row -> SentNoteEntity in
+//                try row.decode()
+//            }).first
+    }
+}

package/ios/ZCashLightClientKit/DAO/PagedTransactionDao.swift

@@ -0,0 +1,62 @@
+//
+//  File.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 12/9/19.
+//
+
+import Foundation
+
+class PagedTransactionDAO: PaginatedTransactionRepository {
+    var pageSize: Int
+    var transactionRepository: TransactionRepository
+    var kind: TransactionKind
+    
+    var pageCount: Int {
+        guard pageSize > 0 else {
+            return 0
+        }
+        return itemCount / pageSize
+    }
+    
+    var itemCount: Int {
+        guard let count = try? 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 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]? {
+        let offset = number * pageSize
+        guard offset < itemCount else { return nil }
+        return try getAll(offset: offset, limit: pageSize, kind: kind)?.map({ $0.transactionEntity })
+    }
+    
+    func page(_ number: Int, result: @escaping (Result<[TransactionEntity]?, Error>) -> Void) {
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self = self else { return }
+            do {
+                result(.success(try self.page(number)))
+            } catch {
+                result(.failure(error))
+            }
+        }
+    }
+}