react-native-zcash 0.3.4 → 0.3.5

package/ios/ZCashLightClientKit/Entity/AccountEntity.swift

@@ -0,0 +1,201 @@
+//
+//  AccountEntity.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/14/19.
+//
+
+import Foundation
+
+protocol AccountEntity {
+    var account: Int { get set }
+    var extfvk: String { get set }
+    var address: String { get set }
+    var transparentAddress: String { get set }
+}
+
+struct Account: 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
+        }
+    }
+    
+    var zAddress: SaplingShieldedAddress {
+        get {
+            address
+        }
+        // swiftlint:disable unused_setter_value
+        set {
+            address = transparentAddress
+        }
+    }
+}
+
+extension Account: Hashable {
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(account)
+        hasher.combine(extfvk)
+        hasher.combine(address)
+        hasher.combine(transparentAddress)
+    }
+    
+    static func == (lhs: Self, rhs: Self) -> Bool {
+        guard
+            lhs.account == rhs.account,
+            lhs.extfvk == rhs.extfvk,
+            lhs.address == rhs.address,
+            lhs.transparentAddress == rhs.transparentAddress
+        else { return false }
+        
+        return true
+    }
+}
+
+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")
+    }
+
+    let table = Table("accounts")
+
+    var dbProvider: ConnectionProvider
+    
+    init (dbProvider: ConnectionProvider) {
+        self.dbProvider = dbProvider
+    }
+    
+    func getAll() throws -> [AccountEntity] {
+        let allAccounts: [Account] = try dbProvider.connection().prepare(table).map({ row in
+            try row.decode()
+        })
+        
+        return allAccounts
+    }
+    
+    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
+    }
+    
+    func update(_ account: AccountEntity) throws {
+        guard let acc = account as? Account else {
+            throw StorageError.updateFailed
+        }
+        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
+        }
+    }
+}
+
+class CachingAccountDao: AccountRepository {
+    var 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 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 {
+        if caching {
+            return CachingAccountDao(dao: AccountSQDAO(dbProvider: SimpleConnectionProvider(path: dataDbURL.path, readonly: readOnly)))
+        } else {
+            return AccountSQDAO(dbProvider: SimpleConnectionProvider(path: dataDbURL.path, readonly: readOnly))
+        }
+    }
+}

package/ios/ZCashLightClientKit/Entity/CompactBlockEntity.swift

@@ -0,0 +1,13 @@
+//
+//  CompactBlockEntity.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/16/19.
+//
+
+import Foundation
+
+protocol CompactBlockEntity {
+    var height: BlockHeight { get set }
+    var data: Data { get set }
+}

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: SignedTransactionEntity {
+    var transactionId: Data
+    var 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/PendingTransactionEntity.swift

@@ -0,0 +1,205 @@
+//
+//  PendingTransactionEntity.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/19/19.
+//
+
+import Foundation
+/**
+Represents a sent transaction that has not been confirmed yet on the blockchain
+*/
+public protocol PendingTransactionEntity: SignedTransactionEntity, AbstractTransaction, RawIdentifiable {
+    /**
+    recipient address
+    */
+    var toAddress: String { get set }
+
+    /**
+    index of the account from which the funds were sent
+    */
+    var accountIndex: Int { get set }
+    
+    /**
+    height which the block was mined at.
+    -1 when block has not been mined yet
+    */
+    var minedHeight: BlockHeight { get set }
+
+    /**
+    height for which the represented transaction would be considered expired
+    */
+    var expiryHeight: BlockHeight { get set }
+
+    /**
+    value is 1 if the transaction was cancelled
+    */
+    var cancelled: Int { get set }
+
+    /**
+    how many times this transaction encoding was attempted
+    */
+    var encodeAttempts: Int { get set }
+    
+    /**
+    How many attempts to send this transaction have been done
+    */
+    var submitAttempts: Int { get set }
+
+    /**
+    Error message if available.
+    */
+    var errorMessage: String? { get set }
+
+    /**
+    error code, if available
+    */
+    var errorCode: Int? { get set }
+
+    /**
+    create time of the represented transaction
+     
+    - Note: represented in timeIntervalySince1970
+    */
+    var createTime: TimeInterval { get set }
+    
+    /**
+    Checks whether this transaction is the same as the given transaction
+    */
+    func isSameTransactionId<T: RawIdentifiable> (other: T) -> Bool
+    
+    /**
+    returns whether the represented transaction is pending based on the provided block height
+    */
+    func isPending(currentHeight: Int) -> Bool
+    
+    /**
+    if the represented transaction is being created
+    */
+    var isCreating: Bool { get }
+    
+    /**
+    returns whether the represented transaction has failed to be encoded
+    */
+    var isFailedEncoding: Bool { get }
+
+    /**
+    returns whether the represented transaction has failed to be submitted
+    */
+    var isFailedSubmit: Bool { get }
+    
+    /**
+    returns whether the represented transaction presents some kind of error
+    */
+    var isFailure: Bool { get }
+
+    /**
+    returns whether the represented transaction has been cancelled by the user
+    */
+    var isCancelled: Bool { get }
+
+    /**
+    returns whether the represented transaction has been successfully mined
+    */
+    var isMined: Bool { get }
+
+    /**
+    returns whether the represented transaction has been submitted
+    */
+    var isSubmitted: Bool { get }
+    
+    /**
+    returns whether the represented transaction has been submitted successfully
+    */
+    var isSubmitSuccess: Bool { get }
+}
+
+public extension PendingTransactionEntity {
+    func isSameTransaction<T: RawIdentifiable>(other: T) -> Bool {
+        guard let selfId = self.rawTransactionId, let otherId = other.rawTransactionId else { return false }
+        return selfId == otherId
+    }
+    
+    var isCreating: Bool {
+        (raw?.isEmpty ?? true) != false && submitAttempts <= 0 && !isFailedSubmit && !isFailedEncoding
+    }
+    
+    var isFailedEncoding: Bool {
+        (raw?.isEmpty ?? true) != false && encodeAttempts > 0
+    }
+    
+    var isFailedSubmit: Bool {
+        errorMessage != nil || (errorCode != nil && (errorCode ?? 0) < 0)
+    }
+    
+    var isFailure: Bool {
+        isFailedEncoding || isFailedSubmit
+    }
+    
+    var isCancelled: Bool {
+        cancelled > 0
+    }
+    
+    var isMined: Bool {
+        minedHeight > 0
+    }
+    
+    var isSubmitted: Bool {
+        submitAttempts > 0
+    }
+    
+    func isPending(currentHeight: Int = -1) -> Bool {
+        // not mined and not expired and successfully created
+        isSubmitSuccess && !isConfirmed(currentHeight: currentHeight) && (expiryHeight == -1 || expiryHeight > currentHeight) && raw != nil
+    }
+        
+    var isSubmitSuccess: Bool {
+        submitAttempts > 0 && (errorCode == nil || (errorCode ?? 0) >= 0) && errorMessage == nil
+    }
+    
+    func isConfirmed(currentHeight: Int = -1 ) -> Bool {
+        guard minedHeight > 0 else {
+            return false
+        }
+        
+        guard currentHeight > 0 else {
+            return false
+        }
+        
+        return abs(currentHeight - minedHeight) >= ZcashSDK.defaultStaleTolerance
+    }
+}
+
+public extension PendingTransactionEntity {
+    /**
+    TransactionEntity representation of this PendingTransactionEntity transaction
+    */
+    var transactionEntity: TransactionEntity {
+        Transaction(
+            id: self.id ?? -1,
+            transactionId: self.rawTransactionId ?? Data(),
+            created: Date(timeIntervalSince1970: self.createTime).description,
+            transactionIndex: -1,
+            expiryHeight: self.expiryHeight,
+            minedHeight: self.minedHeight,
+            raw: self.raw
+        )
+    }
+}
+
+public extension ConfirmedTransactionEntity {
+    /**
+    TransactionEntity representation of this ConfirmedTransactionEntity transaction
+    */
+    var transactionEntity: TransactionEntity {
+        Transaction(
+            id: self.id ?? -1,
+            transactionId: self.rawTransactionId ?? Data(),
+            created: Date(timeIntervalSince1970: self.blockTimeInSeconds).description,
+            transactionIndex: self.transactionIndex,
+            expiryHeight: self.expiryHeight,
+            minedHeight: self.minedHeight,
+            raw: self.raw
+        )
+    }
+}

package/ios/ZCashLightClientKit/Entity/ReceivedNoteEntity.swift

@@ -0,0 +1,22 @@
+//
+//  ReceivedNotesEntity.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/14/19.
+//
+
+import Foundation
+
+protocol ReceivedNoteEntity {
+    var id: Int { get set }
+    var transactionId: Int { get set }
+    var outputIndex: Int { get set }
+    var account: Int { get set }
+    var value: Int { get set }
+    var memo: Data? { get set }
+    var spent: Int? { get set }
+    var diversifier: Data { get set }
+    var rcm: Data { get set }
+    var nf: Data { get set }
+    var isChange: Bool { get set }
+}

package/ios/ZCashLightClientKit/Entity/SentNoteEntity.swift

@@ -0,0 +1,45 @@
+//
+//  Sent.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/14/19.
+//
+
+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 }
+}
+    
+extension SentNoteEntity {
+    static func == (lhs: Self, rhs: Self) -> Bool {
+        guard lhs.id == rhs.id,
+            lhs.transactionId == rhs.transactionId,
+            lhs.outputIndex == rhs.outputIndex,
+            lhs.account == rhs.account,
+            lhs.address == rhs.address,
+            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(account)
+        hasher.combine(address)
+        hasher.combine(value)
+        if let memo = memo {
+            hasher.combine(memo)
+        } else {
+            hasher.combine(Int(0))
+        }
+    }
+}

package/ios/ZCashLightClientKit/Entity/TransactionEntity.swift

@@ -0,0 +1,161 @@
+//
+//  File.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/14/19.
+//
+
+import Foundation
+/**
+convenience representation of all transaction types
+*/
+public protocol TransactionEntity {
+    /**
+    Internal transaction id
+    */
+    var id: Int? { get set }
+
+    /**
+    Blockchain transaction id
+    */
+    var transactionId: Data { get set }
+
+    /**
+    String representing the date  of creation
+     
+    format is yyyy-MM-dd'T'HH:MM:ss.SSSSSSSSSZ
+    - Example:  2019-12-04T17:49:10.636624000Z
+    */
+    var created: String? { get set }
+    var transactionIndex: Int? { get set }
+    var expiryHeight: BlockHeight? { get set }
+    var minedHeight: BlockHeight? { get set }
+    var raw: Data? { get set }
+}
+
+/**
+Hashable extension default implementation
+*/
+public extension TransactionEntity {
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(id)
+        hasher.combine(transactionId)
+        hasher.combine(expiryHeight)
+        hasher.combine(minedHeight)
+        hasher.combine(raw)
+    }
+    
+    static func == (lhs: Self, rhs: Self) -> Bool {
+        guard
+            lhs.id == rhs.id,
+            lhs.transactionId == rhs.transactionId,
+            lhs.created == rhs.created,
+            lhs.expiryHeight == rhs.expiryHeight,
+            lhs.minedHeight == rhs.minedHeight,
+            ((lhs.raw != nil && rhs.raw != nil) || (lhs.raw == nil && rhs.raw == nil))
+        else { return false }
+        
+        if let lhsRaw = lhs.raw, let rhsRaw = rhs.raw {
+            return lhsRaw == rhsRaw
+        }
+        
+        return true
+    }
+    
+    func anchor(network: ZcashNetwork) -> BlockHeight? {
+        if let minedHeight = self.minedHeight, minedHeight != -1 {
+            return max(minedHeight - ZcashSDK.defaultStaleTolerance, network.constants.saplingActivationHeight)
+        }
+        
+        if let expiryHeight = self.expiryHeight, expiryHeight != -1 {
+            return max(expiryHeight - ZcashSDK.expiryOffset - ZcashSDK.defaultStaleTolerance, network.constants.saplingActivationHeight)
+        }
+        
+        return nil
+    }
+}
+
+/**
+Abstract representation of all transaction types
+*/
+public protocol AbstractTransaction {
+    /**
+    internal id for this transaction
+    */
+    var id: Int? { get set }
+
+    /**
+    value in zatoshi
+    */
+    var value: Int { get set }
+
+    /**
+    data containing the memo if any
+    */
+    var memo: Data? { get set }
+}
+
+/**
+Capabilites of a signed transaction
+*/
+public protocol SignedTransactionEntity {
+    var raw: Data? { get set }
+}
+
+/**
+Capabilities of an entity that can be uniquely identified by a raw transaction id
+*/
+public protocol RawIdentifiable {
+    var rawTransactionId: Data? { get set }
+}
+
+/**
+Attributes that a Mined transaction must have
+*/
+public protocol MinedTransactionEntity: AbstractTransaction, RawIdentifiable {
+    /**
+    height on which this transaction was mined at. Convention is that -1 is retuned when it has not been mined yet
+    */
+    var minedHeight: Int { get set }
+    
+    /**
+    internal note id that is involved on this transaction
+    */
+    var noteId: Int { get set }
+
+    /**
+    block time in in reference since 1970
+    */
+    var blockTimeInSeconds: TimeInterval { get set }
+
+    /**
+    internal index for this transaction
+    */
+    var transactionIndex: Int { get set }
+}
+
+public protocol ConfirmedTransactionEntity: MinedTransactionEntity, SignedTransactionEntity {
+    /**
+    recipient address if available
+    */
+    var toAddress: String? { get set }
+
+    /**
+    expiration height for this transaction
+    */
+    var expiryHeight: BlockHeight? { get set }
+}
+
+public extension ConfirmedTransactionEntity {
+    var isOutbound: Bool {
+        self.toAddress != nil
+    }
+    
+    var isInbound: Bool {
+        self.toAddress == nil
+    }
+    
+    var blockTimeInMilliseconds: Double {
+        self.blockTimeInSeconds * 1000
+    }
+}

package/ios/ZCashLightClientKit/Entity/UnspentTransactionOutputEntity.swift

@@ -0,0 +1,17 @@
+//
+//  UnspentTransactionOutputEntity.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 12/9/20.
+//
+
+import Foundation
+
+public protocol UnspentTransactionOutputEntity {
+    var address: String { get set }
+    var txid: Data { get set }
+    var index: Int { get set }
+    var script: Data { get set }
+    var valueZat: Int { get set }
+    var height: Int { get set }
+}

package/ios/ZCashLightClientKit/Extensions/Data+Zcash.swift

@@ -0,0 +1,17 @@
+//
+//  Data+Zcash.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 1/10/20.
+//
+
+import Foundation
+
+public extension Data {
+    /**
+    Transforms the data info bytes into a Zcash hex transaction id
+    */
+    func toHexStringTxId() -> String {
+        self.hexEncodedString().toTxIdString()
+    }
+}