react-native-zcash 0.3.5 → 0.4.0

package/ios/ZCashLightClientKit/DAO/UnspentTransactionOutputDao.swift

@@ -19,14 +19,14 @@ struct UTXO: Decodable, Encodable {
         case spentInTx = "spent_in_tx"
     }
     
-    var id: Int?
-    var address: String
+    let id: Int?
+    let address: String
     var prevoutTxId: Data
     var prevoutIndex: Int
-    var script: Data
-    var valueZat: Int
-    var height: Int
-    var spentInTx: Int?
+    let script: Data
+    let valueZat: Int
+    let height: Int
+    let spentInTx: Int?
 }
 
 extension UTXO: UnspentTransactionOutputEntity {
@@ -69,25 +69,30 @@ extension UnspentTransactionOutputEntity {
 import SQLite
 class UnspentTransactionOutputSQLDAO: UnspentTransactionOutputRepository {
     enum TableColumns {
-        static var id = Expression<Int>("id_utxo")
-        static var address = Expression<String>("address")
-        static var txid = Expression<Blob>("prevout_txid")
-        static var index = Expression<Int>("prevout_idx")
-        static var script = Expression<Blob>("script")
-        static var valueZat = Expression<Int>("value_zat")
-        static var height = Expression<Int>("height")
-        static var spentInTx = Expression<Int?>("spent_in_tx")
+        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")
 
-    var dbProvider: ConnectionProvider
+    let dbProvider: ConnectionProvider
     
-    init (dbProvider: ConnectionProvider) {
+    init(dbProvider: ConnectionProvider) {
         self.dbProvider = dbProvider
     }
+
+    /// - Throws: `unspentTransactionOutputDAOCreateTable` if creation table fails.
+    func initialise() async throws {
+        try await createTableIfNeeded()
+    }
     
-    func createTableIfNeeded() throws {
+    private func createTableIfNeeded() async throws {
         let stringStatement =
             """
             CREATE TABLE IF NOT EXISTS utxos (
@@ -103,11 +108,15 @@ class UnspentTransactionOutputSQLDAO: UnspentTransactionOutputRepository {
                 CONSTRAINT tx_outpoint UNIQUE (prevout_txid, prevout_idx)
             )
             """
-        
-        try dbProvider.connection().run(stringStatement)
+        do {
+            try dbProvider.connection().run(stringStatement)
+        } catch {
+            throw ZcashError.unspentTransactionOutputDAOCreateTable(error)
+        }
     }
 
-    func store(utxos: [UnspentTransactionOutputEntity]) throws {
+    /// - Throws: `unspentTransactionOutputDAOStore` if sqlite query fails.
+    func store(utxos: [UnspentTransactionOutputEntity]) async throws {
         do {
             let db = try dbProvider.connection()
             try dbProvider.connection().transaction {
@@ -116,45 +125,58 @@ class UnspentTransactionOutputSQLDAO: UnspentTransactionOutputRepository {
                 }
             }
         } catch {
-            throw StorageError.transactionFailed(underlyingError: error)
+            throw ZcashError.unspentTransactionOutputDAOStore(error)
         }
     }
 
-    func clearAll(address: String?) throws {
-        if let tAddr = address {
-            do {
+    /// - 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())
-            } catch {
-                throw StorageError.operationFailed
-            }
-        } else {
-            do {
+            } else {
                 try dbProvider.connection().run(table.delete())
-            } catch {
-                throw StorageError.operationFailed
             }
+        } catch {
+            throw ZcashError.unspentTransactionOutputDAOClearAll(error)
         }
     }
-    
-    func getAll(address: String?) throws -> [UnspentTransactionOutputEntity] {
-        if let tAddress = address {
-            let allTxs: [UTXO] = try dbProvider.connection()
-                .prepare(table.filter(TableColumns.address == tAddress))
-                .map { row in
-                    try row.decode()
-                }
-            return allTxs
-        } else {
-            let allTxs: [UTXO] = try dbProvider.connection()
-                .prepare(table)
-                .map { row in
-                    try row.decode()
-                }
-            return allTxs
+
+    ///  - 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)
+            }
         }
     }
-    
-    func balance(address: String, latestHeight: BlockHeight) throws -> WalletBalance {
+
+    /// - 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)
@@ -166,23 +188,23 @@ class UnspentTransactionOutputSQLDAO: UnspentTransactionOutputRepository {
                     .filter(TableColumns.address == address)
             ) ?? 0
             
-            return TransparentBalance(verified: Int64(verified), total: Int64(total), address: address)
+            return WalletBalance(
+                verified: Zatoshi(Int64(verified)),
+                total: Zatoshi(Int64(total))
+            )
         } catch {
-            throw StorageError.operationFailed
+            throw ZcashError.unspentTransactionOutputDAOBalance(error)
         }
     }
 }
 
-struct TransparentBalance: WalletBalance {
-    var verified: Int64
-    var total: Int64
+struct TransparentBalance {
+    var balance: WalletBalance
     var address: String
 }
 
 enum UTXORepositoryBuilder {
-    static func build(initializer: Initializer) throws -> UnspentTransactionOutputRepository {
-        let dao = UnspentTransactionOutputSQLDAO(dbProvider: SimpleConnectionProvider(path: initializer.dataDbURL.path))
-        try dao.createTableIfNeeded()
-        return dao
+    static func build(initializer: Initializer) -> UnspentTransactionOutputRepository {
+        return UnspentTransactionOutputSQLDAO(dbProvider: SimpleConnectionProvider(path: initializer.dataDbURL.path))
     }
 }

package/ios/ZCashLightClientKit/Entity/AccountEntity.swift

@@ -6,66 +6,33 @@
 //
 
 import Foundation
+import SQLite
 
 protocol AccountEntity {
-    var account: Int { get set }
-    var extfvk: String { get set }
-    var address: String { get set }
-    var transparentAddress: String { get set }
+    var account: Int { get }
+    var ufvk: String { get }
 }
 
-struct Account: AccountEntity, Encodable, Decodable {
+struct DbAccount: AccountEntity, Encodable, Decodable {
     enum CodingKeys: String, CodingKey {
         case account
-        case extfvk
-        case address
-        case transparentAddress = "transparent_address"
-    }
-    
-    var account: Int
-    
-    var extfvk: String
-    
-    var address: String
-    
-    var transparentAddress: String
-}
-
-extension Account: UnifiedAddress {
-    var tAddress: TransparentAddress {
-        get {
-            transparentAddress
-        }
-        set {
-            transparentAddress = newValue
-        }
+        case ufvk
     }
     
-    var zAddress: SaplingShieldedAddress {
-        get {
-            address
-        }
-        // swiftlint:disable unused_setter_value
-        set {
-            address = transparentAddress
-        }
-    }
+    let account: Int
+    let ufvk: String
 }
 
-extension Account: Hashable {
+extension DbAccount: Hashable {
     func hash(into hasher: inout Hasher) {
         hasher.combine(account)
-        hasher.combine(extfvk)
-        hasher.combine(address)
-        hasher.combine(transparentAddress)
+        hasher.combine(ufvk)
     }
     
     static func == (lhs: Self, rhs: Self) -> Bool {
         guard
             lhs.account == rhs.account,
-            lhs.extfvk == rhs.extfvk,
-            lhs.address == rhs.address,
-            lhs.transparentAddress == rhs.transparentAddress
+            lhs.ufvk == rhs.ufvk
         else { return false }
         
         return true
@@ -75,60 +42,97 @@ extension Account: Hashable {
 protocol AccountRepository {
     func getAll() throws -> [AccountEntity]
     func findBy(account: Int) throws -> AccountEntity?
-    func findBy(address: String) throws -> AccountEntity?
     func update(_ account: AccountEntity) throws
 }
 
-import SQLite
-
 class AccountSQDAO: AccountRepository {
     enum TableColums {
         static let account = Expression<Int>("account")
-        static let extfvk = Expression<String>("extfvk")
-        static let address = Expression<String>("address")
-        static let transparentAddress = Expression<String>("transparent_address")
+        static let extfvk = Expression<String>("ufvk")
     }
 
     let table = Table("accounts")
 
-    var dbProvider: ConnectionProvider
+    let dbProvider: ConnectionProvider
+    let logger: Logger
     
-    init (dbProvider: ConnectionProvider) {
+    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] {
-        let allAccounts: [Account] = try dbProvider.connection().prepare(table).map({ row in
-            try row.decode()
-        })
-        
-        return allAccounts
+        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)
-        return try dbProvider.connection().prepare(query).map({ try $0.decode() as Account }).first
-    }
-    
-    func findBy(address: String) throws -> AccountEntity? {
-        let query = table.filter(TableColums.address == address).limit(1)
-        return try dbProvider.connection().prepare(query).map({ try $0.decode() as Account }).first
+        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? Account else {
-            throw StorageError.updateFailed
+        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)
         }
-        let updatedRows = try dbProvider.connection().run(table.filter(TableColums.account == acc.account).update(acc))
+
         if updatedRows == 0 {
-            LoggerProxy.error("attempted to update pending transactions but no rows were updated")
-            throw StorageError.updateFailed
+            logger.error("attempted to update pending transactions but no rows were updated")
+            throw ZcashError.accountDAOUpdatedZeroRows
         }
     }
 }
 
 class CachingAccountDao: AccountRepository {
-    var dao: AccountRepository
+    let dao: AccountRepository
     lazy var cache: [Int: AccountEntity] = {
         var accountCache: [Int: AccountEntity] = [:]
         guard let all = try? dao.getAll() else {
@@ -170,32 +174,26 @@ class CachingAccountDao: AccountRepository {
 
         return acc
     }
-    
-    func findBy(address: String) throws -> AccountEntity? {
-        if !cache.isEmpty, let account = cache.values.first(where: { $0.address == address }) {
-            return account
-        }
         
-        guard let account = try dao.findBy(address: address) else {
-            return nil
-        }
-
-        cache[account.account] = account
-        
-        return account
-    }
-    
     func update(_ account: AccountEntity) throws {
         try dao.update(account)
     }
 }
 
 enum AccountRepositoryBuilder {
-    static func build(dataDbURL: URL, readOnly: Bool = false, caching: Bool = false) -> AccountRepository {
+    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)))
+            return CachingAccountDao(
+                dao: AccountSQDAO(
+                    dbProvider: SimpleConnectionProvider(path: dataDbURL.path, readonly: readOnly),
+                    logger: logger
+                )
+            )
         } else {
-            return AccountSQDAO(dbProvider: SimpleConnectionProvider(path: dataDbURL.path, readonly: readOnly))
+            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

@@ -7,9 +7,9 @@
 
 import Foundation
 
-struct EncodedTransaction: SignedTransactionEntity {
-    var transactionId: Data
-    var raw: Data?
+struct EncodedTransaction {
+    let transactionId: Data
+    let raw: Data
 }
 
 extension EncodedTransaction: Hashable {

package/ios/ZCashLightClientKit/Entity/SentNoteEntity.swift

@@ -8,13 +8,14 @@
 import Foundation
 
 protocol SentNoteEntity {
-    var id: Int { get set }
-    var transactionId: Int { get set }
-    var outputIndex: Int { get set }
-    var account: Int { get set }
-    var address: String { get set }
-    var value: Int { get set }
-    var memo: Data? { get set }
+    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 {
@@ -22,8 +23,9 @@ extension SentNoteEntity {
         guard lhs.id == rhs.id,
             lhs.transactionId == rhs.transactionId,
             lhs.outputIndex == rhs.outputIndex,
-            lhs.account == rhs.account,
-            lhs.address == rhs.address,
+            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
@@ -33,10 +35,11 @@ extension SentNoteEntity {
         hasher.combine(id)
         hasher.combine(transactionId)
         hasher.combine(outputIndex)
-        hasher.combine(account)
-        hasher.combine(address)
+        hasher.combine(fromAccount)
+        hasher.combine(toAddress)
+        hasher.combine(toAccount)
         hasher.combine(value)
-        if let memo = memo {
+        if let memo {
             hasher.combine(memo)
         } else {
             hasher.combine(Int(0))