react-native-zcash 0.3.4 → 0.4.0

package/ios/ZCashLightClientKit/DAO/UnspentTransactionOutputDao.swift

@@ -0,0 +1,210 @@
+//
+//  UnspentTransactionOutputDAO.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 12/9/20.
+//
+
+import Foundation
+
+struct UTXO: Decodable, Encodable {
+    enum CodingKeys: String, CodingKey {
+        case id = "id_utxo"
+        case address
+        case prevoutTxId = "prevout_txid"
+        case prevoutIndex = "prevout_idx"
+        case script
+        case valueZat = "value_zat"
+        case height
+        case spentInTx = "spent_in_tx"
+    }
+    
+    let id: Int?
+    let address: String
+    var prevoutTxId: Data
+    var prevoutIndex: Int
+    let script: Data
+    let valueZat: Int
+    let height: Int
+    let spentInTx: Int?
+}
+
+extension UTXO: UnspentTransactionOutputEntity {
+    var txid: Data {
+        get {
+            prevoutTxId
+        }
+        set {
+            prevoutTxId = newValue
+        }
+    }
+    
+    var index: Int {
+        get {
+            prevoutIndex
+        }
+        set {
+            prevoutIndex = newValue
+        }
+    }
+}
+
+extension UnspentTransactionOutputEntity {
+    /**
+    As UTXO, with id and spentIntTx set to __nil__
+    */
+    func asUTXO() -> UTXO {
+        UTXO(
+            id: nil,
+            address: address,
+            prevoutTxId: txid,
+            prevoutIndex: index,
+            script: script,
+            valueZat: valueZat,
+            height: height,
+            spentInTx: nil
+        )
+    }
+}
+import SQLite
+class UnspentTransactionOutputSQLDAO: UnspentTransactionOutputRepository {
+    enum TableColumns {
+        static let id = Expression<Int>("id_utxo")
+        static let address = Expression<String>("address")
+        static let txid = Expression<Blob>("prevout_txid")
+        static let index = Expression<Int>("prevout_idx")
+        static let script = Expression<Blob>("script")
+        static let valueZat = Expression<Int>("value_zat")
+        static let height = Expression<Int>("height")
+        static let spentInTx = Expression<Int?>("spent_in_tx")
+    }
+
+    let table = Table("utxos")
+
+    let dbProvider: ConnectionProvider
+    
+    init(dbProvider: ConnectionProvider) {
+        self.dbProvider = dbProvider
+    }
+
+    /// - Throws: `unspentTransactionOutputDAOCreateTable` if creation table fails.
+    func initialise() async throws {
+        try await createTableIfNeeded()
+    }
+    
+    private func createTableIfNeeded() async throws {
+        let stringStatement =
+            """
+            CREATE TABLE IF NOT EXISTS utxos (
+                id_utxo INTEGER PRIMARY KEY,
+                address TEXT NOT NULL,
+                prevout_txid BLOB NOT NULL,
+                prevout_idx INTEGER NOT NULL,
+                script BLOB NOT NULL,
+                value_zat INTEGER NOT NULL,
+                height INTEGER NOT NULL,
+                spent_in_tx INTEGER,
+                FOREIGN KEY (spent_in_tx) REFERENCES transactions(id_tx),
+                CONSTRAINT tx_outpoint UNIQUE (prevout_txid, prevout_idx)
+            )
+            """
+        do {
+            try dbProvider.connection().run(stringStatement)
+        } catch {
+            throw ZcashError.unspentTransactionOutputDAOCreateTable(error)
+        }
+    }
+
+    /// - Throws: `unspentTransactionOutputDAOStore` if sqlite query fails.
+    func store(utxos: [UnspentTransactionOutputEntity]) async throws {
+        do {
+            let db = try dbProvider.connection()
+            try dbProvider.connection().transaction {
+                for utxo in utxos.map({ $0 as? UTXO ?? $0.asUTXO() }) {
+                    try db.run(table.insert(utxo))
+                }
+            }
+        } catch {
+            throw ZcashError.unspentTransactionOutputDAOStore(error)
+        }
+    }
+
+    /// - Throws: `unspentTransactionOutputDAOClearAll` if sqlite query fails.
+    func clearAll(address: String?) async throws {
+        do {
+            if let tAddr = address {
+                try dbProvider.connection().run(table.filter(TableColumns.address == tAddr).delete())
+            } else {
+                try dbProvider.connection().run(table.delete())
+            }
+        } catch {
+            throw ZcashError.unspentTransactionOutputDAOClearAll(error)
+        }
+    }
+
+    ///  - Throws:
+    ///     - `unspentTransactionOutputDAOClearAll` if the data fetched from the DB can't be decoded to `UTXO` object.
+    ///     - `unspentTransactionOutputDAOGetAll` if sqlite query fails.
+    func getAll(address: String?) async throws -> [UnspentTransactionOutputEntity] {
+        do {
+            if let tAddress = address {
+                let allTxs: [UTXO] = try dbProvider.connection()
+                    .prepare(table.filter(TableColumns.address == tAddress))
+                    .map { row in
+                        do {
+                            return try row.decode()
+                        } catch {
+                            throw ZcashError.unspentTransactionOutputDAOGetAllCantDecode(error)
+                        }
+                    }
+                return allTxs
+            } else {
+                let allTxs: [UTXO] = try dbProvider.connection()
+                    .prepare(table)
+                    .map { row in
+                        try row.decode()
+                    }
+                return allTxs
+            }
+        } catch {
+            if let error = error as? ZcashError {
+                throw error
+            } else {
+                throw ZcashError.unspentTransactionOutputDAOGetAll(error)
+            }
+        }
+    }
+
+    /// - Throws: `unspentTransactionOutputDAOBalance` if sqlite query fails.
+    func balance(address: String, latestHeight: BlockHeight) async throws -> WalletBalance {
+        do {
+            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().scalar(
+                table.select(TableColumns.valueZat.sum)
+                    .filter(TableColumns.address == address)
+            ) ?? 0
+            
+            return WalletBalance(
+                verified: Zatoshi(Int64(verified)),
+                total: Zatoshi(Int64(total))
+            )
+        } catch {
+            throw ZcashError.unspentTransactionOutputDAOBalance(error)
+        }
+    }
+}
+
+struct TransparentBalance {
+    var balance: WalletBalance
+    var address: String
+}
+
+enum UTXORepositoryBuilder {
+    static func build(initializer: Initializer) -> UnspentTransactionOutputRepository {
+        return UnspentTransactionOutputSQLDAO(dbProvider: SimpleConnectionProvider(path: initializer.dataDbURL.path))
+    }
+}

package/ios/ZCashLightClientKit/Entity/AccountEntity.swift

@@ -0,0 +1,199 @@
+//
+//  AccountEntity.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/14/19.
+//
+
+import Foundation
+import SQLite
+
+protocol AccountEntity {
+    var account: Int { get }
+    var ufvk: String { get }
+}
+
+struct DbAccount: AccountEntity, Encodable, Decodable {
+    enum CodingKeys: String, CodingKey {
+        case account
+        case ufvk
+    }
+    
+    let account: Int
+    let ufvk: String
+}
+
+extension DbAccount: Hashable {
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(account)
+        hasher.combine(ufvk)
+    }
+    
+    static func == (lhs: Self, rhs: Self) -> Bool {
+        guard
+            lhs.account == rhs.account,
+            lhs.ufvk == rhs.ufvk
+        else { return false }
+        
+        return true
+    }
+}
+
+protocol AccountRepository {
+    func getAll() throws -> [AccountEntity]
+    func findBy(account: Int) throws -> AccountEntity?
+    func update(_ account: AccountEntity) throws
+}
+
+class AccountSQDAO: AccountRepository {
+    enum TableColums {
+        static let account = Expression<Int>("account")
+        static let extfvk = Expression<String>("ufvk")
+    }
+
+    let table = Table("accounts")
+
+    let dbProvider: ConnectionProvider
+    let logger: Logger
+    
+    init(dbProvider: ConnectionProvider, logger: Logger) {
+        self.dbProvider = dbProvider
+        self.logger = logger
+    }
+
+    /// - Throws:
+    ///     - `accountDAOGetAllCantDecode` if account data fetched from the db can't be decoded to the `Account` object.
+    ///     - `accountDAOGetAll` if sqlite query fetching account data failed.
+    func getAll() throws -> [AccountEntity] {
+        do {
+            return try dbProvider.connection()
+                .prepare(table)
+                .map { row -> DbAccount in
+                    do {
+                        return try row.decode()
+                    } catch {
+                        throw ZcashError.accountDAOGetAllCantDecode(error)
+                    }
+                }
+        } catch {
+            if let error = error as? ZcashError {
+                throw error
+            } else {
+                throw ZcashError.accountDAOGetAll(error)
+            }
+        }
+    }
+
+    /// - Throws:
+    ///     - `accountDAOFindByCantDecode` if account data fetched from the db can't be decoded to the `Account` object.
+    ///     - `accountDAOFindBy` if sqlite query fetching account data failed.
+    func findBy(account: Int) throws -> AccountEntity? {
+        let query = table.filter(TableColums.account == account).limit(1)
+        do {
+            return try dbProvider.connection()
+                .prepare(query)
+                .map {
+                    do {
+                        return try $0.decode() as DbAccount
+                    } catch {
+                        throw ZcashError.accountDAOFindByCantDecode(error)
+                    }
+                }
+                .first
+        } catch {
+            if let error = error as? ZcashError {
+                throw error
+            } else {
+                throw ZcashError.accountDAOFindBy(error)
+            }
+        }
+    }
+
+    /// - Throws:
+    ///     - `accountDAOUpdate` if sqlite query updating account failed.
+    ///     - `accountDAOUpdatedZeroRows` if sqlite query updating account pass but it affects 0 rows.
+    func update(_ account: AccountEntity) throws {
+        guard let acc = account as? DbAccount else {
+            throw ZcashError.accountDAOUpdateInvalidAccount
+        }
+
+        let updatedRows: Int
+        do {
+            updatedRows = try dbProvider.connection().run(table.filter(TableColums.account == acc.account).update(acc))
+        } catch {
+            throw ZcashError.accountDAOUpdate(error)
+        }
+
+        if updatedRows == 0 {
+            logger.error("attempted to update pending transactions but no rows were updated")
+            throw ZcashError.accountDAOUpdatedZeroRows
+        }
+    }
+}
+
+class CachingAccountDao: AccountRepository {
+    let dao: AccountRepository
+    lazy var cache: [Int: AccountEntity] = {
+        var accountCache: [Int: AccountEntity] = [:]
+        guard let all = try? dao.getAll() else {
+            return accountCache
+        }
+
+        for acc in all {
+            accountCache[acc.account] = acc
+        }
+
+        return accountCache
+    }()
+    
+    init(dao: AccountRepository) {
+        self.dao = dao
+    }
+    
+    func getAll() throws -> [AccountEntity] {
+        guard cache.isEmpty else {
+            return cache.values.sorted(by: { $0.account < $1.account })
+        }
+
+        let all = try dao.getAll()
+        
+        for acc in all {
+            cache[acc.account] = acc
+        }
+
+        return all
+    }
+    
+    func findBy(account: Int) throws -> AccountEntity? {
+        if let acc = cache[account] {
+            return acc
+        }
+        
+        let acc = try dao.findBy(account: account)
+        cache[account] = acc
+
+        return acc
+    }
+        
+    func update(_ account: AccountEntity) throws {
+        try dao.update(account)
+    }
+}
+
+enum AccountRepositoryBuilder {
+    static func build(dataDbURL: URL, readOnly: Bool = false, caching: Bool = false, logger: Logger) -> AccountRepository {
+        if caching {
+            return CachingAccountDao(
+                dao: AccountSQDAO(
+                    dbProvider: SimpleConnectionProvider(path: dataDbURL.path, readonly: readOnly),
+                    logger: logger
+                )
+            )
+        } else {
+            return AccountSQDAO(
+                dbProvider: SimpleConnectionProvider(path: dataDbURL.path, readonly: readOnly),
+                logger: logger
+            )
+        }
+    }
+}

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/EncodedTransactionEntity.swift

@@ -0,0 +1,26 @@
+//
+//  EncodedTransactionEntity.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/19/19.
+//
+
+import Foundation
+
+struct EncodedTransaction {
+    let transactionId: Data
+    let raw: Data
+}
+
+extension EncodedTransaction: Hashable {
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(transactionId)
+        hasher.combine(raw)
+    }
+    
+    static func == (lhs: Self, rhs: Self) -> Bool {
+        guard lhs.transactionId == rhs.transactionId else { return false }
+        guard lhs.raw == rhs.raw else { return false }
+        return true
+    }
+}

package/ios/ZCashLightClientKit/Entity/SentNoteEntity.swift

@@ -0,0 +1,48 @@
+//
+//  Sent.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/14/19.
+//
+
+import Foundation
+
+protocol SentNoteEntity {
+    var id: Int { get }
+    var transactionId: Int { get }
+    var outputIndex: Int { get }
+    var fromAccount: Int { get }
+    var toAddress: String? { get }
+    var toAccount: Int? { get }
+    var value: Int { get }
+    var memo: Data? { get }
+}
+    
+extension SentNoteEntity {
+    static func == (lhs: Self, rhs: Self) -> Bool {
+        guard lhs.id == rhs.id,
+            lhs.transactionId == rhs.transactionId,
+            lhs.outputIndex == rhs.outputIndex,
+            lhs.fromAccount == rhs.fromAccount,
+            lhs.toAddress == rhs.toAddress,
+            lhs.toAccount == rhs.toAccount,
+            lhs.value == rhs.value,
+            lhs.memo == rhs.memo else { return false }
+        return true
+    }
+            
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(id)
+        hasher.combine(transactionId)
+        hasher.combine(outputIndex)
+        hasher.combine(fromAccount)
+        hasher.combine(toAddress)
+        hasher.combine(toAccount)
+        hasher.combine(value)
+        if let memo {
+            hasher.combine(memo)
+        } else {
+            hasher.combine(Int(0))
+        }
+    }
+}