react-native-zcash 0.6.14 → 0.7.1

package/ios/ZCashLightClientKit/ClosureSynchronizer.swift

@@ -36,6 +36,64 @@ public protocol ClosureSynchronizer {
     func getUnifiedAddress(accountIndex: Int, completion: @escaping (Result<UnifiedAddress, Error>) -> Void)
     func getTransparentAddress(accountIndex: Int, completion: @escaping (Result<TransparentAddress, Error>) -> Void)
 
+    /// Creates a proposal for transferring funds to the given recipient.
+    ///
+    /// - Parameter accountIndex: the account from which to transfer funds.
+    /// - Parameter recipient: the recipient's address.
+    /// - Parameter amount: the amount to send in Zatoshi.
+    /// - Parameter memo: an optional memo to include as part of the proposal's transactions. Use `nil` when sending to transparent receivers otherwise the function will throw an error.
+    ///
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
+    /// `SynchronizerErrors.notPrepared`.
+    func proposeTransfer(
+        accountIndex: Int,
+        recipient: Recipient,
+        amount: Zatoshi,
+        memo: Memo?,
+        completion: @escaping (Result<Proposal, Error>) -> Void
+    )
+
+    /// Creates a proposal for shielding any transparent funds received by the given account.
+    ///
+    /// - Parameter accountIndex: the account for which to shield funds.
+    /// - Parameter shieldingThreshold: the minimum transparent balance required before a proposal will be created.
+    /// - Parameter memo: an optional memo to include as part of the proposal's transactions.
+    /// - Parameter transparentReceiver: a specific transparent receiver within the account
+    ///             that should be the source of transparent funds. Default is `nil` which
+    ///             will select whichever of the account's transparent receivers has funds
+    ///             to shield.
+    ///
+    /// Returns the proposal, or `nil` if the transparent balance that would be shielded
+    /// is zero or below `shieldingThreshold`.
+    ///
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
+    /// `SynchronizerErrors.notPrepared`.
+    func proposeShielding(
+        accountIndex: Int,
+        shieldingThreshold: Zatoshi,
+        memo: Memo,
+        transparentReceiver: TransparentAddress?,
+        completion: @escaping (Result<Proposal?, Error>) -> Void
+    )
+
+    /// Creates the transactions in the given proposal.
+    ///
+    /// - Parameter proposal: the proposal for which to create transactions.
+    /// - Parameter spendingKey: the `UnifiedSpendingKey` associated with the account for which the proposal was created.
+    ///
+    /// Returns a stream of objects for the transactions that were created as part of the
+    /// proposal, indicating whether they were submitted to the network or if an error
+    /// occurred.
+    ///
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance
+    /// or since the last wipe then this method throws `SynchronizerErrors.notPrepared`.
+    func createProposedTransactions(
+        proposal: Proposal,
+        spendingKey: UnifiedSpendingKey,
+        completion: @escaping (Result<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>) -> Void
+    )
+
+    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
     func sendToAddress(
         spendingKey: UnifiedSpendingKey,
         zatoshi: Zatoshi,
@@ -44,6 +102,7 @@ public protocol ClosureSynchronizer {
         completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
     )
 
+    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
     func shieldFunds(
         spendingKey: UnifiedSpendingKey,
         memo: Memo,
@@ -68,12 +127,8 @@ public protocol ClosureSynchronizer {
 
     func refreshUTXOs(address: TransparentAddress, from height: BlockHeight, completion: @escaping (Result<RefreshedUTXOs, Error>) -> Void)
 
-    func getTransparentBalance(accountIndex: Int, completion: @escaping (Result<WalletBalance, Error>) -> Void)
-
-    func getShieldedBalance(accountIndex: Int, completion: @escaping (Result<Zatoshi, Error>) -> Void)
-
-    func getShieldedVerifiedBalance(accountIndex: Int, completion: @escaping (Result<Zatoshi, Error>) -> Void)
-
+    func getAccountBalance(accountIndex: Int, completion: @escaping (Result<AccountBalance?, Error>) -> Void)
+    
     /*
      It can be missleading that these two methods are returning Publisher even this protocol is closure based. Reason is that Synchronizer doesn't
      provide different implementations for these two methods. So Combine it is even here.

package/ios/ZCashLightClientKit/CombineSynchronizer.swift

@@ -35,19 +35,80 @@ public protocol CombineSynchronizer {
     func getUnifiedAddress(accountIndex: Int) -> SinglePublisher<UnifiedAddress, Error>
     func getTransparentAddress(accountIndex: Int) -> SinglePublisher<TransparentAddress, Error>
 
+    /// Creates a proposal for transferring funds to the given recipient.
+    ///
+    /// - Parameter accountIndex: the account from which to transfer funds.
+    /// - Parameter recipient: the recipient's address.
+    /// - Parameter amount: the amount to send in Zatoshi.
+    /// - Parameter memo: an optional memo to include as part of the proposal's transactions. Use `nil` when sending to transparent receivers otherwise the function will throw an error.
+    ///
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
+    /// `SynchronizerErrors.notPrepared`.
+    func proposeTransfer(
+        accountIndex: Int,
+        recipient: Recipient,
+        amount: Zatoshi,
+        memo: Memo?
+    ) -> SinglePublisher<Proposal, Error>
+
+    /// Creates a proposal for shielding any transparent funds received by the given account.
+    ///
+    /// - Parameter accountIndex: the account for which to shield funds.
+    /// - Parameter shieldingThreshold: the minimum transparent balance required before a proposal will be created.
+    /// - Parameter memo: an optional memo to include as part of the proposal's transactions.
+    /// - Parameter transparentReceiver: a specific transparent receiver within the account
+    ///             that should be the source of transparent funds. Default is `nil` which
+    ///             will select whichever of the account's transparent receivers has funds
+    ///             to shield.
+    ///
+    /// Returns the proposal, or `nil` if the transparent balance that would be shielded
+    /// is zero or below `shieldingThreshold`.
+    ///
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
+    /// `SynchronizerErrors.notPrepared`.
+    func proposeShielding(
+        accountIndex: Int,
+        shieldingThreshold: Zatoshi,
+        memo: Memo,
+        transparentReceiver: TransparentAddress?
+    ) -> SinglePublisher<Proposal?, Error>
+
+    /// Creates the transactions in the given proposal.
+    ///
+    /// - Parameter proposal: the proposal for which to create transactions.
+    /// - Parameter spendingKey: the `UnifiedSpendingKey` associated with the account for which the proposal was created.
+    ///
+    /// Returns a stream of objects for the transactions that were created as part of the
+    /// proposal, indicating whether they were submitted to the network or if an error
+    /// occurred.
+    ///
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance
+    /// or since the last wipe then this method throws `SynchronizerErrors.notPrepared`.
+    func createProposedTransactions(
+        proposal: Proposal,
+        spendingKey: UnifiedSpendingKey
+    ) -> SinglePublisher<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>
+
+    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
     func sendToAddress(
         spendingKey: UnifiedSpendingKey,
         zatoshi: Zatoshi,
         toAddress: Recipient,
         memo: Memo?
     ) -> SinglePublisher<ZcashTransaction.Overview, Error>
-
+    
+    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients. use `proposeShielding:` instead")
     func shieldFunds(
         spendingKey: UnifiedSpendingKey,
         memo: Memo,
         shieldingThreshold: Zatoshi
     ) -> SinglePublisher<ZcashTransaction.Overview, Error>
 
+    func proposefulfillingPaymentURI(
+        _ uri: String,
+        accountIndex: Int
+    ) -> SinglePublisher<Proposal, Error>
+
     var allTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
     var sentTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
     var receivedTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
@@ -64,9 +125,7 @@ public protocol CombineSynchronizer {
 
     func refreshUTXOs(address: TransparentAddress, from height: BlockHeight) -> SinglePublisher<RefreshedUTXOs, Error>
 
-    func getTransparentBalance(accountIndex: Int) -> SinglePublisher<WalletBalance, Error>
-    func getShieldedBalance(accountIndex: Int) -> SinglePublisher<Zatoshi, Error>
-    func getShieldedVerifiedBalance(accountIndex: Int) -> SinglePublisher<Zatoshi, Error>
+    func getAccountBalance(accountIndex: Int) -> SinglePublisher<AccountBalance?, Error>
 
     func rewind(_ policy: RewindPolicy) -> CompletablePublisher<Error>
     func wipe() -> CompletablePublisher<Error>

package/ios/ZCashLightClientKit/Constants/ZcashSDK.swift

@@ -105,6 +105,10 @@ public enum ZcashSDK {
     // TODO: [#1304] smart retry logic, https://github.com/zcash/ZcashLightClientKit/issues/1304
     public static let defaultRetries = Int.max
 
+    /// The communication errors are usually false positive and another try will continue the work, 
+    /// in case the service is trully down we cap the amount of retries by this value.
+    public static let serviceFailureRetries = 3
+
     /// 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

package/ios/ZCashLightClientKit/DAO/TransactionDao.swift

@@ -8,22 +8,6 @@
 import Foundation
 import SQLite
 
-extension Connection {
-    public func scalarLocked<V: Value>(_ query: ScalarQuery<V?>) throws -> V.ValueType? {
-        globalDBLock.lock()
-        defer { globalDBLock.unlock() }
-
-        return try scalar(query)
-    }
-    
-    public func scalarLocked<V: Value>(_ query: ScalarQuery<V>) throws -> V {
-        globalDBLock.lock()
-        defer { globalDBLock.unlock() }
-
-        return try scalar(query)
-    }
-}
-
 class TransactionSQLDAO: TransactionRepository {
     enum NotesTableStructure {
         static let transactionID = Expression<Int>("tx")
@@ -55,17 +39,19 @@ class TransactionSQLDAO: TransactionRepository {
         true
     }
     
+    @DBActor
     func countAll() async throws -> Int {
         do {
-            return try connection().scalarLocked(transactionsView.count)
+            return try connection().scalar(transactionsView.count)
         } catch {
             throw ZcashError.transactionRepositoryCountAll(error)
         }
     }
     
+    @DBActor
     func countUnmined() async throws -> Int {
         do {
-            return try connection().scalarLocked(transactionsView.filter(ZcashTransaction.Overview.Column.minedHeight == nil).count)
+            return try connection().scalar(transactionsView.filter(ZcashTransaction.Overview.Column.minedHeight == nil).count)
         } catch {
             throw ZcashError.transactionRepositoryCountUnmined(error)
         }
@@ -76,7 +62,7 @@ class TransactionSQLDAO: TransactionRepository {
             .filter(ZcashTransaction.Overview.Column.rawID == Blob(bytes: rawID.bytes))
             .limit(1)
 
-        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+        return try await execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
 
     func find(offset: Int, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
@@ -85,7 +71,7 @@ class TransactionSQLDAO: TransactionRepository {
             .filterQueryFor(kind: kind)
             .limit(limit, offset: offset)
 
-        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+        return try await execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
 
     func find(in range: CompactBlockRange, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
@@ -98,7 +84,7 @@ class TransactionSQLDAO: TransactionRepository {
             .filterQueryFor(kind: kind)
             .limit(limit)
 
-        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+        return try await execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
 
     func find(from transaction: ZcashTransaction.Overview, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
@@ -119,7 +105,7 @@ class TransactionSQLDAO: TransactionRepository {
             .filterQueryFor(kind: kind)
             .limit(limit)
         
-        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+        return try await execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
 
     func findReceived(offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview] {
@@ -128,7 +114,7 @@ class TransactionSQLDAO: TransactionRepository {
             .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc)
             .limit(limit, offset: offset)
 
-        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+        return try await execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
 
     func findSent(offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview] {
@@ -137,7 +123,7 @@ class TransactionSQLDAO: TransactionRepository {
             .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc)
             .limit(limit, offset: offset)
 
-        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+        return try await execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
 
     func findPendingTransactions(latestHeight: BlockHeight, offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview] {
@@ -146,7 +132,7 @@ class TransactionSQLDAO: TransactionRepository {
             .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc)
             .limit(limit, offset: offset)
 
-        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+        return try await execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
 
     func findMemos(for transaction: ZcashTransaction.Overview) async throws -> [Memo] {
@@ -162,23 +148,25 @@ class TransactionSQLDAO: TransactionRepository {
         let query = self.txOutputsView
             .filter(ZcashTransaction.Output.Column.rawID == Blob(bytes: rawID.bytes))
 
-        return try execute(query) { try ZcashTransaction.Output(row: $0) }
+        return try await execute(query) { try ZcashTransaction.Output(row: $0) }
     }
 
     func getRecipients(for rawID: Data) async throws -> [TransactionRecipient] {
         try await getTransactionOutputs(for: rawID).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 }
+    private func execute<Entity>(_ query: View, createEntity: (Row) throws -> Entity) async throws -> Entity {
+        let entities: [Entity] = try await 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] {
-        globalDBLock.lock()
-        defer { globalDBLock.unlock() }
-        
+    @DBActor
+    private func execute<Entity>(_ query: View, createEntity: (Row) throws -> Entity) async throws -> [Entity] {
         do {
             let entities = try connection()
                 .prepare(query)

package/ios/ZCashLightClientKit/DAO/UnspentTransactionOutputDao.swift

@@ -8,25 +8,12 @@
 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 {
@@ -48,172 +35,3 @@ extension UTXO: UnspentTransactionOutputEntity {
         }
     }
 }
-
-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 {
-            globalDBLock.lock()
-            defer { globalDBLock.unlock() }
-            
-            try dbProvider.connection().run(stringStatement)
-        } catch {
-            throw ZcashError.unspentTransactionOutputDAOCreateTable(error)
-        }
-    }
-
-    /// - Throws: `unspentTransactionOutputDAOStore` if sqlite query fails.
-    func store(utxos: [UnspentTransactionOutputEntity]) async throws {
-        do {
-            globalDBLock.lock()
-            defer { globalDBLock.unlock() }
-
-            let db = try dbProvider.connection()
-            try db.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 {
-            globalDBLock.lock()
-            defer { globalDBLock.unlock() }
-
-            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().scalarLocked(
-                table.select(TableColumns.valueZat.sum)
-                    .filter(TableColumns.address == address)
-                    .filter(TableColumns.height <= latestHeight - ZcashSDK.defaultStaleTolerance)
-            ) ?? 0
-            let total = try dbProvider.connection().scalarLocked(
-                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))
-    }
-}