react-native-zcash 0.3.4 → 0.3.5

package/ios/ZCashLightClientKit/Tool/DerivationTool.swift

@@ -0,0 +1,344 @@
+//
+//  DerivationTool.swift
+//  Pods
+//
+//  Created by Francisco Gindre on 10/8/20.
+//
+
+import Foundation
+
+public protocol KeyValidation {
+    func isValidExtendedViewingKey(_ extvk: String) throws -> Bool
+    
+    func isValidTransparentAddress(_ tAddress: String) throws -> Bool
+    
+    func isValidShieldedAddress(_ zAddress: String) throws -> Bool
+}
+
+public protocol KeyDeriving {
+    /**
+    Given a seed and a number of accounts, return the associated viewing keys.
+     
+    - Parameter seed: the seed from which to derive viewing keys.
+    - Parameter numberOfAccounts: the number of accounts to use. Multiple accounts are not fully
+    supported so the default value of 1 is recommended.
+     
+    - Returns: the viewing keys that correspond to the seed, formatted as Strings.
+    */
+    func deriveViewingKeys(seed: [UInt8], numberOfAccounts: Int) throws -> [String]
+
+    /**
+    Given a spending key, return the associated viewing key.
+    
+    - Parameter spendingKey: the key from which to derive the viewing key.
+    
+    - Returns: the viewing key that corresponds to the spending key.
+    */
+    func deriveViewingKey(spendingKey: String) throws -> String
+
+    /**
+    Given a seed and a number of accounts, return the associated spending keys.
+    
+    - Parameter seed: the seed from which to derive spending keys.
+    - Parameter numberOfAccounts: the number of accounts to use. Multiple accounts are not fully
+    supported so the default value of 1 is recommended.
+    
+    - Returns: the spending keys that correspond to the seed, formatted as Strings.
+    */
+    func deriveSpendingKeys(seed: [UInt8], numberOfAccounts: Int) throws -> [String]
+    
+    /**
+    Given a seed and account index, return the associated address.
+     
+    - Parameter seed: the seed from which to derive the address.
+    - Parameter accountIndex: the index of the account to use for deriving the address. Multiple
+    accounts are not fully supported so the default value of 1 is recommended.
+     
+    - Returns: the address that corresponds to the seed and account index.
+    */
+    func deriveShieldedAddress(seed: [UInt8], accountIndex: Int) throws -> String
+    
+    /**
+    Given a viewing key string, return the associated address.
+     
+    - Parameter viewingKey: the viewing key to use for deriving the address. The viewing key is tied to
+        a specific account so no account index is required.
+     
+    - Returns: the address that corresponds to the viewing key.
+    */
+    func deriveShieldedAddress(viewingKey: String) throws -> String
+    
+    /**
+    Derives a transparent address  from seedbytes, specifying account and index
+    */
+    func deriveTransparentAddress(seed: [UInt8], account: Int, index: Int) throws -> String
+    
+    /**
+    Derives a SecretKey to spend transparent funds from a transparent secret key wif encoded
+    */
+    func deriveTransparentPrivateKey(seed: [UInt8], account: Int, index: Int) throws -> String
+    
+    /**
+    Derives a transparent address from the given transparent Secret Key
+    */
+    func deriveTransparentAddressFromPrivateKey(_ tsk: String) throws -> String
+    
+    func deriveTransparentAddressFromPublicKey(_ pubkey: String) throws -> String
+    
+    /**
+    derives unified viewing keys from seedbytes, specifying a number of accounts
+    - Returns an array of unified viewing key tuples.
+    */
+    func deriveUnifiedViewingKeysFromSeed(_ seed: [UInt8], numberOfAccounts: Int) throws -> [UnifiedViewingKey]
+    
+    /**
+    derives a Unified Address from a Unified Viewing Key
+    */
+    func deriveUnifiedAddressFromUnifiedViewingKey(_ uvk: UnifiedViewingKey) throws -> UnifiedAddress
+}
+
+public enum KeyDerivationErrors: Error {
+    case derivationError(underlyingError: Error)
+    case unableToDerive
+    case invalidInput
+}
+
+public class DerivationTool: KeyDeriving {
+    var rustwelding: ZcashRustBackendWelding.Type = ZcashRustBackend.self
+    
+    var networkType: NetworkType
+    
+    public init(networkType: NetworkType) {
+        self.networkType = networkType
+    }
+
+    /**
+    Given a seed and a number of accounts, return the associated viewing keys.
+     
+    - Parameter seed: the seed from which to derive viewing keys.
+    - Parameter numberOfAccounts: the number of accounts to use. Multiple accounts are not fully
+    supported so the default value of 1 is recommended.
+     
+    - Returns: the viewing keys that correspond to the seed, formatted as Strings.
+    */
+    public func deriveViewingKeys(seed: [UInt8], numberOfAccounts: Int) throws -> [String] {
+        guard numberOfAccounts > 0, let numberOfAccounts = Int32(exactly: numberOfAccounts) else {
+            throw KeyDerivationErrors.invalidInput
+        }
+        
+        do {
+            guard let keys = try rustwelding.deriveExtendedFullViewingKeys(seed: seed, accounts: numberOfAccounts, networkType: networkType) else {
+                throw KeyDerivationErrors.unableToDerive
+            }
+            return keys
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+    
+    /**
+    Given a spending key, return the associated viewing key.
+    
+    - Parameter spendingKey: the key from which to derive the viewing key.
+    
+    - Returns: the viewing key that corresponds to the spending key.
+    */
+    public func deriveViewingKey(spendingKey: String) throws -> String {
+        do {
+            guard let key = try rustwelding.deriveExtendedFullViewingKey(spendingKey, networkType: networkType) else {
+                throw KeyDerivationErrors.unableToDerive
+            }
+            return key
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+    
+    /**
+    Given a seed and a number of accounts, return the associated spending keys.
+    
+    - Parameter seed: the seed from which to derive spending keys.
+    - Parameter numberOfAccounts: the number of accounts to use. Multiple accounts are not fully
+    supported so the default value of 1 is recommended.
+    
+    - Returns: the spending keys that correspond to the seed, formatted as Strings.
+    */
+    public func deriveSpendingKeys(seed: [UInt8], numberOfAccounts: Int) throws -> [String] {
+        guard numberOfAccounts > 0, let numberOfAccounts = Int32(exactly: numberOfAccounts) else {
+            throw KeyDerivationErrors.invalidInput
+        }
+        do {
+            guard let keys = try rustwelding.deriveExtendedSpendingKeys(seed: seed, accounts: numberOfAccounts, networkType: networkType) else {
+                throw KeyDerivationErrors.unableToDerive
+            }
+            return keys
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+    
+    /**
+    Given a seed and account index, return the associated address.
+     
+    - Parameter seed: the seed from which to derive the address.
+    - Parameter accountIndex: the index of the account to use for deriving the address. Multiple
+    accounts are not fully supported so the default value of 1 is recommended.
+     
+    - Returns: the address that corresponds to the seed and account index.
+    */
+    public func deriveShieldedAddress(seed: [UInt8], accountIndex: Int) throws -> String {
+        guard accountIndex >= 0, let accountIndex = Int32(exactly: accountIndex) else {
+            throw KeyDerivationErrors.invalidInput
+        }
+        
+        do {
+            guard let address = try rustwelding.deriveShieldedAddressFromSeed(seed: seed, accountIndex: accountIndex, networkType: networkType) else {
+                throw KeyDerivationErrors.unableToDerive
+            }
+            return address
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+    
+    /**
+    Given a viewing key string, return the associated address.
+     
+    - Parameter viewingKey: the viewing key to use for deriving the address. The viewing key is tied to
+    a specific account so no account index is required.
+     
+    - Returns: the address that corresponds to the viewing key.
+    */
+    public func deriveShieldedAddress(viewingKey: String) throws -> String {
+        do {
+            guard let zaddr = try rustwelding.deriveShieldedAddressFromViewingKey(viewingKey, networkType: networkType) else {
+                throw KeyDerivationErrors.unableToDerive
+            }
+            return zaddr
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+    
+    public func deriveTransparentAddress(seed: [UInt8], account: Int = 0, index: Int = 0) throws -> String {
+        do {
+            guard let zaddr = try rustwelding.deriveTransparentAddressFromSeed(
+                seed: seed,
+                account: account,
+                index: index,
+                networkType: networkType
+            ) else {
+                throw KeyDerivationErrors.unableToDerive
+            }
+            return zaddr
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+    
+    public func deriveUnifiedViewingKeysFromSeed(_ seed: [UInt8], numberOfAccounts: Int) throws -> [UnifiedViewingKey] {
+        guard numberOfAccounts > 0 else {
+            throw KeyDerivationErrors.invalidInput
+        }
+        do {
+            return try rustwelding.deriveUnifiedViewingKeyFromSeed(seed, numberOfAccounts: numberOfAccounts, networkType: networkType)
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+    
+    /**
+    derives a Unified Address from a Unified Viewing Key
+    */
+    public func deriveUnifiedAddressFromUnifiedViewingKey(_ uvk: UnifiedViewingKey) throws -> UnifiedAddress {
+        do {
+            let tAddress = try deriveTransparentAddressFromPublicKey(uvk.extpub)
+            let zAddress = try deriveShieldedAddress(viewingKey: uvk.extfvk)
+            return ConcreteUnifiedAddress(tAddress: tAddress, zAddress: zAddress)
+        } catch {
+            throw KeyDerivationErrors.unableToDerive
+        }
+    }
+    
+    public func deriveTransparentAddressFromPublicKey(_ pubkey: String) throws -> String {
+        guard !pubkey.isEmpty else {
+            throw KeyDerivationErrors.invalidInput
+        }
+        
+        do {
+            return try rustwelding.derivedTransparentAddressFromPublicKey(pubkey, networkType: networkType)
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+    
+    /**
+    Derives the transparent funds private key from the given seed
+    - Throws:
+    -  KeyDerivationErrors.derivationError with the underlying error when it fails
+    - KeyDerivationErrors.unableToDerive when there's an unknown error
+    */
+    public func deriveTransparentPrivateKey(seed: [UInt8], account: Int = 0, index: Int = 0) throws -> String {
+        do {
+            guard let seedKey = try rustwelding.deriveTransparentPrivateKeyFromSeed(
+                seed: seed,
+                account: account,
+                index: index,
+                networkType: networkType
+            ) else {
+                throw KeyDerivationErrors.unableToDerive
+            }
+            return seedKey
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+}
+
+extension DerivationTool: KeyValidation {
+    public func isValidExtendedViewingKey(_ extvk: String) throws -> Bool {
+        do {
+            return try rustwelding.isValidExtendedFullViewingKey(extvk, networkType: networkType)
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+    
+    public func isValidTransparentAddress(_ tAddress: String) throws -> Bool {
+        do {
+            return try rustwelding.isValidTransparentAddress(tAddress, networkType: networkType)
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+    
+    public func isValidShieldedAddress(_ zAddress: String) throws -> Bool {
+        do {
+            return try rustwelding.isValidShieldedAddress(zAddress, networkType: networkType)
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+    
+    /**
+    Derives the transparent address from a WIF Private Key
+    - Throws:
+        - KeyDerivationErrors.derivationError with the underlying error when it fails
+        - KeyDerivationErrors.unableToDerive when there's an unknown error
+    */
+    public func deriveTransparentAddressFromPrivateKey(_ tsk: String) throws -> String {
+        do {
+            guard let tAddr = try rustwelding.deriveTransparentAddressFromSecretKey(tsk, networkType: networkType) else {
+                throw KeyDerivationErrors.unableToDerive
+            }
+            return tAddr
+        } catch {
+            throw KeyDerivationErrors.derivationError(underlyingError: error)
+        }
+    }
+}
+
+private struct ConcreteUnifiedAddress: UnifiedAddress {
+    var tAddress: TransparentAddress
+    var zAddress: SaplingShieldedAddress
+}

package/ios/ZCashLightClientKit/Transaction/PersistentTransactionManager.swift

@@ -0,0 +1,339 @@
+//
+//  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)
+    }
+}