react-native-zcash 0.3.5 → 0.4.1

package/ios/ZCashLightClientKit/Transaction/PersistentTransactionManager.swift

@@ -1,339 +0,0 @@
-//
-//  PendingTransactionsManager.swift
-//  ZcashLightClientKit
-//
-//  Created by Francisco Gindre on 11/26/19.
-//
-
-import Foundation
-
-enum TransactionManagerError: Error {
-    case couldNotCreateSpend(toAddress: String, account: Int, zatoshi: Int)
-    case encodingFailed(PendingTransactionEntity)
-    case updateFailed(PendingTransactionEntity)
-    case notPending(PendingTransactionEntity)
-    case cancelled(PendingTransactionEntity)
-    case internalInconsistency(PendingTransactionEntity)
-    case submitFailed(PendingTransactionEntity, errorCode: Int)
-    case shieldingEncodingFailed(PendingTransactionEntity, reason: String)
-}
-
-class PersistentTransactionManager: OutboundTransactionManager {
-    var repository: PendingTransactionRepository
-    var encoder: TransactionEncoder
-    var service: LightWalletService
-    var queue: DispatchQueue
-    var network: NetworkType
-    
-    init(
-        encoder: TransactionEncoder,
-        service: LightWalletService,
-        repository: PendingTransactionRepository,
-        networkType: NetworkType
-    ) {
-        self.repository = repository
-        self.encoder = encoder
-        self.service = service
-        self.network = networkType
-        self.queue = DispatchQueue.init(label: "PersistentTransactionManager.serial.queue", qos: .userInitiated)
-    }
-    
-    func initSpend(
-        zatoshi: Int,
-        toAddress: String,
-        memo: String?,
-        from accountIndex: Int
-    ) throws -> PendingTransactionEntity {
-        guard let insertedTx = try repository.find(
-            by: try repository.create(
-                PendingTransaction(
-                    value: zatoshi,
-                    toAddress: toAddress,
-                    memo: memo,
-                    account: accountIndex
-                )
-            )
-        ) else {
-            throw TransactionManagerError.couldNotCreateSpend(
-                toAddress: toAddress,
-                account: accountIndex,
-                zatoshi: zatoshi
-            )
-        }
-        LoggerProxy.debug("pending transaction \(String(describing: insertedTx.id)) created")
-        return insertedTx
-    }
-    
-    func encodeShieldingTransaction(
-        spendingKey: String,
-        tsk: String,
-        pendingTransaction: PendingTransactionEntity,
-        result: @escaping (Result<PendingTransactionEntity, Error>) -> Void
-    ) {
-        queue.async { [weak self] in
-            guard let self = self else { return }
-
-            let derivationTool = DerivationTool(networkType: self.network)
-
-            guard
-                let viewingKey = try? derivationTool.deriveViewingKey(spendingKey: spendingKey),
-                let zAddr = try? derivationTool.deriveShieldedAddress(viewingKey: viewingKey)
-            else {
-                result(
-                    .failure(
-                        TransactionManagerError.shieldingEncodingFailed(
-                            pendingTransaction,
-                            reason: "There was an error Deriving your keys"
-                        )
-                    )
-                )
-                return
-            }
-            
-            guard pendingTransaction.toAddress == zAddr else {
-                result(
-                    .failure(
-                        TransactionManagerError.shieldingEncodingFailed(
-                            pendingTransaction,
-                            reason: """
-                                the recipient address does not match your
-                                derived shielded address. Shielding transactions
-                                addresses must match the ones derived from your keys.
-                                This is a serious error. We are not letting you encode
-                                this shielding transaction because it can lead to loss
-                                of funds
-                            """
-                        )
-                    )
-                )
-                return
-            }
-            do {
-                let encodedTransaction = try self.encoder.createShieldingTransaction(
-                    spendingKey: spendingKey,
-                    tSecretKey: tsk,
-                    memo: pendingTransaction.memo?.asZcashTransactionMemo(),
-                    from: pendingTransaction.accountIndex
-                )
-                let transaction = try self.encoder.expandEncodedTransaction(encodedTransaction)
-
-                var pending = pendingTransaction
-                pending.encodeAttempts += 1
-                pending.raw = encodedTransaction.raw
-                pending.rawTransactionId = encodedTransaction.transactionId
-                pending.expiryHeight = transaction.expiryHeight ?? BlockHeight.empty()
-                pending.minedHeight = transaction.minedHeight ?? BlockHeight.empty()
-
-                try self.repository.update(pending)
-
-                result(.success(pending))
-            } catch StorageError.updateFailed {
-                DispatchQueue.main.async {
-                    result(.failure(TransactionManagerError.updateFailed(pendingTransaction)))
-                }
-            } catch {
-                DispatchQueue.main.async {
-                    result(.failure(error))
-                }
-            }
-        }
-    }
-    
-    func encode(
-        spendingKey: String,
-        pendingTransaction: PendingTransactionEntity,
-        result: @escaping (Result<PendingTransactionEntity, Error>) -> Void
-    ) {
-        queue.async { [weak self] in
-            guard let self = self else { return }
-            do {
-                let encodedTransaction = try self.encoder.createTransaction(
-                    spendingKey: spendingKey,
-                    zatoshi: pendingTransaction.value,
-                    to: pendingTransaction.toAddress,
-                    memo: pendingTransaction.memo?.asZcashTransactionMemo(),
-                    from: pendingTransaction.accountIndex
-                )
-                let transaction = try self.encoder.expandEncodedTransaction(encodedTransaction)
-
-                var pending = pendingTransaction
-                pending.encodeAttempts += 1
-                pending.raw = encodedTransaction.raw
-                pending.rawTransactionId = encodedTransaction.transactionId
-                pending.expiryHeight = transaction.expiryHeight ?? BlockHeight.empty()
-                pending.minedHeight = transaction.minedHeight ?? BlockHeight.empty()
-
-                try self.repository.update(pending)
-
-                result(.success(pending))
-            } catch StorageError.updateFailed {
-                DispatchQueue.main.async {
-                    result(.failure(TransactionManagerError.updateFailed(pendingTransaction)))
-                }
-            } catch {
-                do {
-                    try self.updateOnFailure(transaction: pendingTransaction, error: error)
-                } catch {
-                    DispatchQueue.main.async {
-                        result(.failure(TransactionManagerError.updateFailed(pendingTransaction)))
-                    }
-                }
-                DispatchQueue.main.async {
-                    result(.failure(error))
-                }
-            }
-        }
-    }
-    
-    func submit(
-        pendingTransaction: PendingTransactionEntity,
-        result: @escaping (Result<PendingTransactionEntity, Error>) -> Void
-    ) {
-        guard let txId = pendingTransaction.id else {
-            result(.failure(TransactionManagerError.notPending(pendingTransaction)))// this transaction is not stored
-            return
-        }
-        
-        queue.async { [weak self] in
-            guard let self = self else { return }
-            
-            do {
-                guard let storedTx = try self.repository.find(by: txId) else {
-                    result(.failure(TransactionManagerError.notPending(pendingTransaction)))
-                    return
-                }
-                
-                guard !storedTx.isCancelled  else {
-                    LoggerProxy.debug("ignoring cancelled transaction \(storedTx)")
-                    result(.failure(TransactionManagerError.cancelled(storedTx)))
-                    return
-                }
-                
-                guard let raw = storedTx.raw else {
-                    LoggerProxy.debug("INCONSISTENCY: attempt to send pending transaction \(txId) that has not raw data")
-                    result(.failure(TransactionManagerError.internalInconsistency(storedTx)))
-                    return
-                }
-
-                let response = try self.service.submit(spendTransaction: raw)
-                let transaction = try self.update(transaction: storedTx, on: response)
-
-                guard response.errorCode >= 0 else {
-                    result(.failure(TransactionManagerError.submitFailed(transaction, errorCode: Int(response.errorCode))))
-                    return
-                }
-                
-                result(.success(transaction))
-            } catch {
-                try? self.updateOnFailure(transaction: pendingTransaction, error: error)
-                result(.failure(error))
-            }
-        }
-    }
-    
-    func applyMinedHeight(pendingTransaction: PendingTransactionEntity, minedHeight: BlockHeight) throws -> PendingTransactionEntity {
-        guard let id = pendingTransaction.id else {
-            throw TransactionManagerError.internalInconsistency(pendingTransaction)
-        }
-        
-        guard var transaction = try repository.find(by: id) else {
-            throw TransactionManagerError.notPending(pendingTransaction)
-        }
-        
-        transaction.minedHeight = minedHeight
-        guard let pendingTxId = pendingTransaction.id else {
-            throw TransactionManagerError.updateFailed(pendingTransaction)
-        }
-        do {
-            try repository.applyMinedHeight(minedHeight, id: pendingTxId)
-        } catch {
-            throw TransactionManagerError.updateFailed(transaction)
-        }
-        return transaction
-    }
-    
-    func handleReorg(at height: BlockHeight) throws {
-        guard let affectedTxs = try self.allPendingTransactions()?.filter({ $0.minedHeight >= height }) else {
-            return
-        }
-        
-        try affectedTxs
-            .map { transaction -> PendingTransactionEntity in
-                var updatedTx = transaction
-                updatedTx.minedHeight = -1
-                return updatedTx
-            }
-            .forEach { try self.repository.update($0) }
-    }
-    
-    func monitorChanges(byId: Int, observer: Any) {
-        // TODO: Implement this
-    }
-    
-    func cancel(pendingTransaction: PendingTransactionEntity) -> Bool {
-        guard let id = pendingTransaction.id else { return false }
-        
-        guard let transaction = try? repository.find(by: id) else { return false }
-        
-        guard !transaction.isSubmitted else { return false }
-        
-        guard (try? repository.cancel(transaction)) != nil else { return false }
-
-        return true
-    }
-    
-    func allPendingTransactions() throws -> [PendingTransactionEntity]? {
-        try repository.getAll()
-    }
-    
-    // MARK: other functions
-    private func updateOnFailure(transaction: PendingTransactionEntity, error: Error) throws {
-        var pending = transaction
-        pending.errorMessage = error.localizedDescription
-        pending.encodeAttempts = transaction.encodeAttempts + 1
-        try self.repository.update(pending)
-    }
-    
-    private func update(transaction: PendingTransactionEntity, on sendResponse: LightWalletServiceResponse) throws -> PendingTransactionEntity {
-        var pendingTx = transaction
-        pendingTx.submitAttempts += 1
-        let error = sendResponse.errorCode < 0
-        pendingTx.errorCode = error ? Int(sendResponse.errorCode) : nil
-        pendingTx.errorMessage = error ? sendResponse.errorMessage : nil
-        try repository.update(pendingTx)
-        return pendingTx
-    }
-    
-    func delete(pendingTransaction: PendingTransactionEntity) throws {
-        do {
-            try repository.delete(pendingTransaction)
-        } catch {
-            throw TransactionManagerError.notPending(pendingTransaction)
-        }
-    }
-}
-
-enum OutboundTransactionManagerBuilder {
-    static func build(initializer: Initializer) throws -> OutboundTransactionManager {
-        PersistentTransactionManager(
-            encoder: TransactionEncoderbuilder.build(initializer: initializer),
-            service: initializer.lightWalletService,
-            repository: try PendingTransactionRepositoryBuilder.build(initializer: initializer),
-            networkType: initializer.network.networkType
-        )
-    }
-}
-
-enum PendingTransactionRepositoryBuilder {
-    static func build(initializer: Initializer) throws -> PendingTransactionRepository {
-        let dao = PendingTransactionSQLDAO(dbProvider: SimpleConnectionProvider(path: initializer.pendingDbURL.path, readonly: false))
-        try dao.createrTableIfNeeded()
-        return dao
-    }
-}
-
-enum TransactionEncoderbuilder {
-    static func build(initializer: Initializer) -> TransactionEncoder {
-        WalletTransactionEncoder(initializer: initializer)
-    }
-}

package/ios/ZCashLightClientKit/Transaction/TransactionManager.swift

@@ -1,42 +0,0 @@
-//
-//  TransactionManager.swift
-//  ZcashLightClientKit
-//
-//  Created by Francisco Gindre on 11/26/19.
-//
-
-import Foundation
-
-/**
-Manage outbound transactions with the main purpose of reporting which ones are still pending,
-particularly after failed attempts or dropped connectivity. The intent is to help see outbound
-transactions through to completion.
-*/
-
-protocol OutboundTransactionManager {
-    func initSpend(zatoshi: Int, toAddress: String, memo: String?, from accountIndex: Int) throws -> PendingTransactionEntity
-
-    func encodeShieldingTransaction(spendingKey: String, tsk: String, pendingTransaction: PendingTransactionEntity, result: @escaping (Result<PendingTransactionEntity, Error>) -> Void)
-    
-    func encode(spendingKey: String, pendingTransaction: PendingTransactionEntity, result: @escaping (Result<PendingTransactionEntity, Error>) -> Void)
-    
-    func submit(pendingTransaction: PendingTransactionEntity, result: @escaping (Result<PendingTransactionEntity, Error>) -> Void)
-    
-    func applyMinedHeight(pendingTransaction: PendingTransactionEntity, minedHeight: BlockHeight) throws -> PendingTransactionEntity
-    
-    func monitorChanges(byId: Int, observer: Any) // check this out. code smell
-    
-    /**
-    Attempts to Cancel a transaction. Returns true if successful
-    */
-    func cancel(pendingTransaction: PendingTransactionEntity) -> Bool
-    
-    func allPendingTransactions() throws -> [PendingTransactionEntity]?
-    
-    func handleReorg(at blockHeight: BlockHeight) throws
-    
-    /**
-    Deletes a pending transaction from the database
-    */
-    func delete(pendingTransaction: PendingTransactionEntity) throws
-}

package/ios/ZCashLightClientKit/Utils/Bundle+module.swift

@@ -1,30 +0,0 @@
-// N.B This file is copied from the one that SPM generates to give a
-// `Bundle.module` variable. Using the macro we include this only for non-SPM
-// distribution methods, which we equate to "CocoaPods".
-// We use CocoaPods' "Resource Bundles" to copy the resources that we need and
-// we have called our main one "Resources" (see the podspec file), hence the hardcoded name.
-#if !SWIFT_PACKAGE
-import class Foundation.Bundle
-
-private class BundleFinder {}
-
-extension Foundation.Bundle {
-  /// Returns the resource bundle associated with the current Swift module.
-  static var module: Bundle = {
-    let bundleName = "Resources"
-
-    let candidates = [
-      // Bundle should be present here when the package is linked into a framework.
-      Bundle(for: BundleFinder.self).resourceURL
-    ]
-
-    for candidate in candidates {
-      let bundlePath = candidate?.appendingPathComponent(bundleName + ".bundle")
-      if let bundle = bundlePath.flatMap(Bundle.init(url:)) {
-        return bundle
-      }
-    }
-    fatalError("unable to find bundle named Resources")
-  }()
-}
-#endif