react-native-zcash 0.3.4 → 0.3.5

package/ios/ZCashLightClientKit/DAO/PendingTransactionDao.swift

@@ -0,0 +1,213 @@
+//
+//  PendingTransactionDao.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/19/19.
+//
+
+import Foundation
+import SQLite
+struct PendingTransaction: PendingTransactionEntity, Decodable, Encodable {
+    enum CodingKeys: String, CodingKey {
+        case toAddress = "to_address"
+        case accountIndex = "account_index"
+        case minedHeight = "mined_height"
+        case expiryHeight = "expiry_height"
+        case cancelled
+        case encodeAttempts = "encode_attempts"
+        case submitAttempts = "submit_attempts"
+        case errorMessage = "error_message"
+        case errorCode = "error_code"
+        case createTime = "create_time"
+        case raw
+        case id
+        case value
+        case memo
+        case rawTransactionId = "txid"
+    }
+    
+    var toAddress: String
+    var accountIndex: Int
+    var minedHeight: BlockHeight
+    var expiryHeight: BlockHeight
+    var cancelled: Int
+    var encodeAttempts: Int
+    var submitAttempts: Int
+    var errorMessage: String?
+    var errorCode: Int?
+    var createTime: TimeInterval
+    var raw: Data?
+    var id: Int?
+    var value: Int
+    var memo: Data?
+    var rawTransactionId: Data?
+
+    static func from(entity: PendingTransactionEntity) -> PendingTransaction {
+        PendingTransaction(
+            toAddress: entity.toAddress,
+            accountIndex: entity.accountIndex,
+            minedHeight: entity.minedHeight,
+            expiryHeight: entity.expiryHeight,
+            cancelled: entity.cancelled,
+            encodeAttempts: entity.encodeAttempts,
+            submitAttempts: entity.submitAttempts,
+            errorMessage: entity.errorMessage,
+            errorCode: entity.errorCode,
+            createTime: entity.createTime,
+            raw: entity.raw,
+            id: entity.id,
+            value: entity.value,
+            memo: entity.memo,
+            rawTransactionId: entity.raw
+        )
+    }
+
+    func isSameTransactionId<T>(other: T) -> Bool where T: RawIdentifiable {
+        self.rawTransactionId == other.rawTransactionId
+    }
+}
+
+extension PendingTransaction {
+    // TODO: Handle Memo
+    init(value: Int, toAddress: String, memo: String?, account index: Int) {
+        self = PendingTransaction(
+            toAddress: toAddress,
+            accountIndex: index,
+            minedHeight: -1,
+            expiryHeight: -1,
+            cancelled: 0,
+            encodeAttempts: 0,
+            submitAttempts: 0,
+            errorMessage: nil,
+            errorCode: nil,
+            createTime: Date().timeIntervalSince1970,
+            raw: nil,
+            id: nil,
+            value: Int(value),
+            memo: memo?.encodeAsZcashTransactionMemo(),
+            rawTransactionId: nil
+        )
+    }
+}
+
+class PendingTransactionSQLDAO: PendingTransactionRepository {
+    enum TableColumns {
+        static var toAddress = Expression<String>("to_address")
+        static var accountIndex = Expression<Int>("account_index")
+        static var minedHeight = Expression<Int?>("mined_height")
+        static var expiryHeight = Expression<Int?>("expiry_height")
+        static var cancelled = Expression<Int?>("cancelled")
+        static var encodeAttempts = Expression<Int?>("encode_attempts")
+        static var errorMessage = Expression<String?>("error_message")
+        static var submitAttempts = Expression<Int?>("submit_attempts")
+        static var errorCode = Expression<Int?>("error_code")
+        static var createTime = Expression<TimeInterval?>("create_time")
+        static var raw = Expression<Blob?>("raw")
+        static var id = Expression<Int>("id")
+        static var value = Expression<Int>("value")
+        static var memo = Expression<Blob?>("memo")
+        static var rawTransactionId = Expression<Blob?>("txid")
+    }
+
+    let table = Table("pending_transactions")
+    
+    var dbProvider: ConnectionProvider
+   
+    init(dbProvider: ConnectionProvider) {
+        self.dbProvider = dbProvider
+    }
+    
+    func createrTableIfNeeded() throws {
+        let statement = table.create(ifNotExists: true) { createdTable in
+            createdTable.column(TableColumns.id, primaryKey: .autoincrement)
+            createdTable.column(TableColumns.toAddress)
+            createdTable.column(TableColumns.accountIndex)
+            createdTable.column(TableColumns.minedHeight)
+            createdTable.column(TableColumns.expiryHeight)
+            createdTable.column(TableColumns.cancelled)
+            createdTable.column(TableColumns.encodeAttempts, defaultValue: 0)
+            createdTable.column(TableColumns.errorMessage)
+            createdTable.column(TableColumns.errorCode)
+            createdTable.column(TableColumns.submitAttempts, defaultValue: 0)
+            createdTable.column(TableColumns.createTime)
+            createdTable.column(TableColumns.rawTransactionId)
+            createdTable.column(TableColumns.value)
+            createdTable.column(TableColumns.raw)
+            createdTable.column(TableColumns.memo)
+        }
+       
+        try dbProvider.connection().run(statement)
+    }
+    
+    func create(_ transaction: PendingTransactionEntity) throws -> Int {
+        let pendingTx = transaction as? PendingTransaction ?? PendingTransaction.from(entity: transaction)
+        
+        return try Int(dbProvider.connection().run(table.insert(pendingTx)))
+    }
+    
+    func update(_ transaction: PendingTransactionEntity) throws {
+        let pendingTx = transaction as? PendingTransaction ?? PendingTransaction.from(entity: transaction)
+        guard let id = pendingTx.id else {
+            throw StorageError.malformedEntity(fields: ["id"])
+        }
+
+        let updatedRows = try dbProvider.connection().run(table.filter(TableColumns.id == id).update(pendingTx))
+        if updatedRows == 0 {
+            LoggerProxy.error("attempted to update pending transactions but no rows were updated")
+        }
+    }
+    
+    func delete(_ transaction: PendingTransactionEntity) throws {
+        guard let id = transaction.id else {
+            throw StorageError.malformedEntity(fields: ["id"])
+        }
+
+        do {
+            try dbProvider.connection().run(table.filter(TableColumns.id == id).delete())
+        } catch {
+            throw StorageError.updateFailed
+        }
+    }
+    
+    func cancel(_ transaction: PendingTransactionEntity) throws {
+        var pendingTx = transaction as? PendingTransaction ?? PendingTransaction.from(entity: transaction)
+        pendingTx.cancelled = 1
+        guard let txId = pendingTx.id else {
+            throw StorageError.malformedEntity(fields: ["id"])
+        }
+
+        try dbProvider.connection().run(table.filter(TableColumns.id == txId).update(pendingTx))
+    }
+    
+    func find(by id: Int) throws -> PendingTransactionEntity? {
+        guard let row = try dbProvider.connection().pluck(table.filter(TableColumns.id == id).limit(1)) else {
+            return nil
+        }
+
+        do {
+            let pendingTx: PendingTransaction = try row.decode()
+            return pendingTx
+        } catch {
+            throw StorageError.operationFailed
+        }
+    }
+    
+    func getAll() throws -> [PendingTransactionEntity] {
+        let allTxs: [PendingTransaction] = try dbProvider.connection().prepare(table).map { row in
+            try row.decode()
+        }
+
+        return allTxs
+    }
+    
+    func applyMinedHeight(_ height: BlockHeight, id: Int) throws {
+        let transaction = table.filter(TableColumns.id == id)
+        
+        let updatedRows = try dbProvider.connection()
+            .run(transaction.update([TableColumns.minedHeight <- height]))
+        
+        if updatedRows == 0 {
+            LoggerProxy.error("attempted to update a row but none was updated")
+        }
+    }
+}

package/ios/ZCashLightClientKit/DAO/TransactionBuilder.swift

@@ -0,0 +1,169 @@
+//
+//  TransactionBuilder.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/18/19.
+//
+
+import Foundation
+import SQLite
+
+enum TransactionBuilder {
+    enum ConfirmedColumns: Int {
+        case id
+        case minedHeight
+        case transactionIndex
+        case rawTransactionId
+        case expiryHeight
+        case raw
+        case toAddress
+        case value
+        case memo
+        case noteId
+        case blockTimeInSeconds
+    }
+    
+    enum ReceivedColumns: Int {
+        case id
+        case minedHeight
+        case transactionIndex
+        case rawTransactionId
+        case raw
+        case value
+        case memo
+        case noteId
+        case blockTimeInSeconds
+    }
+    
+    enum TransactionEntityColumns: Int {
+        case id
+        case minedHeight
+        case txIndex
+        case txid
+        case expiryHeight
+        case raw
+    }
+    
+    static func createTransactionEntity(txId: Data, rawTransaction: RawTransaction) -> TransactionEntity {
+        Transaction(
+            id: nil,
+            transactionId: txId,
+            created: nil,
+            transactionIndex: nil,
+            expiryHeight: nil,
+            minedHeight: Int(exactly: rawTransaction.height),
+            raw: rawTransaction.data
+        )
+    }
+    
+    static func createTransactionEntity(from bindings: [Binding?]) -> TransactionEntity? {
+        guard let txId = bindings[TransactionEntityColumns.txid.rawValue] as? Blob else {
+            return nil
+        }
+
+        var rawData: Data?
+        if let raw = bindings[TransactionEntityColumns.raw.rawValue] as? Blob {
+            rawData = Data(blob: raw)
+        }
+
+        return Transaction(
+            id: bindings[TransactionEntityColumns.id.rawValue] as? Int,
+            transactionId: Data(blob: txId),
+            created: nil,
+            transactionIndex: bindings[TransactionEntityColumns.txIndex.rawValue] as? Int,
+            expiryHeight: bindings[TransactionEntityColumns.expiryHeight.rawValue] as? Int,
+            minedHeight: bindings[TransactionEntityColumns.minedHeight.rawValue] as? Int,
+            raw: rawData
+        )
+    }
+    
+    static func createConfirmedTransaction(from bindings: [Binding?]) -> ConfirmedTransaction? {
+        guard
+            let id = bindings[ConfirmedColumns.id.rawValue] as? Int64,
+            let noteId = bindings[ConfirmedColumns.noteId.rawValue] as? Int64,
+            let transactionIndex = bindings[ConfirmedColumns.transactionIndex.rawValue] as? Int64,
+            let value = bindings[ConfirmedColumns.value.rawValue] as? Int64
+        else { return nil }
+        
+        let minedHeight = bindings[ConfirmedColumns.minedHeight.rawValue] as? Int64 ?? -1
+        let blockTimeInSeconds = bindings[ConfirmedColumns.blockTimeInSeconds.rawValue] as? Int64 ?? 0
+        // Optional values
+        
+        let toAddress = bindings[ConfirmedColumns.toAddress.rawValue] as? String
+
+        var expiryHeight: BlockHeight?
+        if let expiry = bindings[ConfirmedColumns.expiryHeight.rawValue] as? Int64 {
+            expiryHeight = BlockHeight(expiry)
+        }
+        
+        var raw: Data?
+        if let rawBlob = bindings[ConfirmedColumns.raw.rawValue] as? Blob {
+            raw = Data(blob: rawBlob)
+        }
+        
+        var memo: Data?
+        if let memoBlob = bindings[ConfirmedColumns.memo.rawValue] as? Blob {
+            memo = Data(blob: memoBlob)
+        }
+        
+        var transactionId: Data?
+        if let txIdBlob = bindings[ConfirmedColumns.rawTransactionId.rawValue] as? Blob {
+            transactionId = Data(blob: txIdBlob)
+        }
+        
+        return ConfirmedTransaction(
+            toAddress: toAddress,
+            expiryHeight: expiryHeight,
+            minedHeight: Int(minedHeight),
+            noteId: Int(noteId),
+            blockTimeInSeconds: TimeInterval(integerLiteral: blockTimeInSeconds),
+            transactionIndex: Int(transactionIndex),
+            raw: raw,
+            id: Int(id),
+            value: Int(value),
+            memo: memo,
+            rawTransactionId: transactionId
+        )
+    }
+    
+    static func createReceivedTransaction(from bindings: [Binding?]) -> ConfirmedTransaction? {
+        guard let id = bindings[ReceivedColumns.id.rawValue] as? Int64,
+            let minedHeight = bindings[ReceivedColumns.minedHeight.rawValue] as? Int64,
+            let noteId = bindings[ReceivedColumns.noteId.rawValue] as? Int64,
+            let blockTimeInSeconds = bindings[ReceivedColumns.blockTimeInSeconds.rawValue] as? Int64,
+            let transactionIndex = bindings[ReceivedColumns.transactionIndex.rawValue] as? Int64,
+            let value = bindings[ReceivedColumns.value.rawValue] as? Int64
+            else { return nil }
+        
+        // Optional values
+        
+        var memo: Data?
+        if let memoBlob = bindings[ReceivedColumns.memo.rawValue] as? Blob {
+            memo = Data(blob: memoBlob)
+        }
+        
+        var transactionId: Data?
+        if let txIdBlob = bindings[ReceivedColumns.rawTransactionId.rawValue] as? Blob {
+            transactionId = Data(blob: txIdBlob)
+        }
+        
+        var rawData: Data?
+        if let rawBlob = bindings[ReceivedColumns.raw.rawValue] as? Blob {
+            rawData = Data(blob: rawBlob)
+        }
+
+        return ConfirmedTransaction(
+            toAddress: nil,
+            expiryHeight: nil,
+            minedHeight: Int(minedHeight),
+            noteId: Int(noteId),
+            blockTimeInSeconds: TimeInterval(integerLiteral: blockTimeInSeconds),
+            transactionIndex: Int(transactionIndex),
+            raw: rawData,
+            id: Int(id),
+            value: Int(value),
+            memo: memo,
+            rawTransactionId: transactionId
+        )
+    }
+}