react-native-zcash 0.3.5 → 0.4.1

package/ios/ZCashLightClientKit/DAO/TransactionDao.swift

@@ -8,370 +8,222 @@
 import Foundation
 import SQLite
 
-struct Transaction: TransactionEntity, Decodable {
-    enum CodingKeys: String, CodingKey {
-        case id = "id_tx"
-        case transactionId = "txid"
-        case created
-        case transactionIndex = "tx_index"
-        case expiryHeight = "expiry_height"
-        case minedHeight = "block"
-        case raw
-    }
-    
-    var id: Int?
-    var transactionId: Data
-    var created: String?
-    var transactionIndex: Int?
-    var expiryHeight: BlockHeight?
-    var minedHeight: BlockHeight?
-    var raw: Data?
-}
-
-struct ConfirmedTransaction: ConfirmedTransactionEntity {
-    var toAddress: String?
-    var expiryHeight: BlockHeight?
-    var minedHeight: Int
-    var noteId: Int
-    var blockTimeInSeconds: TimeInterval
-    var transactionIndex: Int
-    var raw: Data?
-    var id: Int?
-    var value: Int
-    var memo: Data?
-    var rawTransactionId: Data?
-}
-
 class TransactionSQLDAO: TransactionRepository {
-    enum TableStructure {
-        static var id = Expression<Int>(Transaction.CodingKeys.id.rawValue)
-        static var transactionId = Expression<Blob>(Transaction.CodingKeys.transactionId.rawValue)
-        static var created = Expression<String?>(Transaction.CodingKeys.created.rawValue)
-        static var txIndex = Expression<Int?>(Transaction.CodingKeys.transactionIndex.rawValue)
-        static var expiryHeight = Expression<Int?>(Transaction.CodingKeys.expiryHeight.rawValue)
-        static var minedHeight = Expression<Int?>(Transaction.CodingKeys.minedHeight.rawValue)
-        static var raw = Expression<Blob?>(Transaction.CodingKeys.raw.rawValue)
+    enum NotesTableStructure {
+        static let transactionID = Expression<Int>("tx")
+        static let memo = Expression<Blob>("memo")
     }
 
-    var dbProvider: ConnectionProvider
-    var transactions = Table("transactions")
-    private var blockDao: BlockSQLDAO
+    let dbProvider: ConnectionProvider
+    
+    private let blockDao: BlockSQLDAO
+    private let transactionsView = View("v_transactions")
+    private let txOutputsView = View("v_tx_outputs")
+    private let traceClosure: ((String) -> Void)?
     
-    init(dbProvider: ConnectionProvider) {
+    init(dbProvider: ConnectionProvider, traceClosure: ((String) -> Void)? = nil) {
         self.dbProvider = dbProvider
         self.blockDao = BlockSQLDAO(dbProvider: dbProvider)
+        self.traceClosure = traceClosure
     }
 
-    func blockForHeight(_ height: BlockHeight) throws -> Block? {
+    private func connection() throws -> Connection {
+        let conn = try dbProvider.connection()
+        conn.trace(traceClosure)
+        return conn
+    }
+
+    func closeDBConnection() {
+        dbProvider.close()
+    }
+
+    func blockForHeight(_ height: BlockHeight) async throws -> Block? {
         try blockDao.block(at: height)
     }
 
-    func lastScannedHeight() throws -> BlockHeight {
+    func lastScannedHeight() async throws -> BlockHeight {
         try blockDao.latestBlockHeight()
     }
 
-    func isInitialized() throws -> Bool {
-        true
+    func lastScannedBlock() async throws -> Block? {
+        try blockDao.latestBlock()
     }
 
-    func findEncodedTransactionBy(txId: Int) -> EncodedTransaction? {
-        // try dbProvider
-        return nil
+    func isInitialized() async throws -> Bool {
+        true
     }
     
-    func countAll() throws -> Int {
-        try dbProvider.connection().scalar(transactions.count)
+    func countAll() async throws -> Int {
+        do {
+            return try connection().scalar(transactionsView.count)
+        } catch {
+            throw ZcashError.transactionRepositoryCountAll(error)
+        }
     }
     
-    func countUnmined() throws -> Int {
-        try dbProvider.connection().scalar(transactions.filter(TableStructure.minedHeight == nil).count)
+    func countUnmined() async throws -> Int {
+        do {
+            return try connection().scalar(transactionsView.filter(ZcashTransaction.Overview.Column.minedHeight == nil).count)
+        } catch {
+            throw ZcashError.transactionRepositoryCountUnmined(error)
+        }
     }
-    
-    func findBy(id: Int) throws -> TransactionEntity? {
-        let query = transactions.filter(TableStructure.id == id).limit(1)
-        let sequence = try dbProvider.connection().prepare(query)
-        let entity: Transaction? = try sequence.map({ try $0.decode() }).first
-        return entity
+
+    func find(id: Int) async throws -> ZcashTransaction.Overview {
+        let query = transactionsView
+            .filter(ZcashTransaction.Overview.Column.id == id)
+            .limit(1)
+
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
-    
-    func findBy(rawId: Data) throws -> TransactionEntity? {
-        let query = transactions.filter(TableStructure.transactionId == Blob(bytes: rawId.bytes)).limit(1)
-        let entity: Transaction? = try dbProvider.connection().prepare(query).map({ try $0.decode() }).first
-        return entity
+
+    func find(rawID: Data) async throws -> ZcashTransaction.Overview {
+        let query = transactionsView
+            .filter(ZcashTransaction.Overview.Column.rawID == Blob(bytes: rawID.bytes))
+            .limit(1)
+
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
-}
 
-// MARK: - Queries
-
-extension TransactionSQLDAO {
-    func findAllSentTransactions(offset: Int = 0, limit: Int = Int.max) throws -> [ConfirmedTransactionEntity]? {
-        try dbProvider.connection()
-            .run(
-                """
-                    SELECT
-                        transactions.id_tx          AS id,
-                        transactions.block          AS minedHeight,
-                        transactions.tx_index       AS transactionIndex,
-                        transactions.txid           AS rawTransactionId,
-                        transactions.expiry_height  AS expiryHeight,
-                        transactions.raw            AS raw,
-                        sent_notes.address          AS toAddress,
-                        sent_notes.value            AS value,
-                        sent_notes.memo             AS memo,
-                        sent_notes.id_note          AS noteId,
-                        blocks.time                 AS blockTimeInSeconds
-                    FROM    transactions
-                        INNER JOIN sent_notes
-                            ON transactions.id_tx = sent_notes.tx
-                        LEFT JOIN blocks
-                            ON transactions.block = blocks.height
-                    WHERE  transactions.raw IS NOT NULL
-                        AND minedheight > 0
-
-                    ORDER  BY block IS NOT NULL, height DESC, time DESC, txid DESC
-                    LIMIT  \(limit) OFFSET \(offset)
-                """
-            )
-            .map { bindings -> ConfirmedTransactionEntity in
-                guard let transaction = TransactionBuilder.createConfirmedTransaction(from: bindings) else {
-                    throw TransactionRepositoryError.malformedTransaction
-                }
-                return transaction
-            }
+    func find(offset: Int, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
+        let query = transactionsView
+            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc, ZcashTransaction.Overview.Column.id.desc)
+            .filterQueryFor(kind: kind)
+            .limit(limit, offset: offset)
+
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
 
-    func findAllReceivedTransactions(offset: Int = 0, limit: Int = Int.max) throws -> [ConfirmedTransactionEntity]? {
-        try dbProvider.connection()
-            .run(
-                """
-                SELECT
-                    transactions.id_tx     AS id,
-                    transactions.block     AS minedHeight,
-                    transactions.tx_index  AS transactionIndex,
-                    transactions.txid      AS rawTransactionId,
-                    transactions.raw       AS raw,
-                    received_notes.value   AS value,
-                    received_notes.memo    AS memo,
-                    received_notes.id_note AS noteId,
-                    blocks.time            AS blockTimeInSeconds
-
-                FROM    transactions
-                    LEFT JOIN received_notes
-                        ON transactions.id_tx = received_notes.tx
-                    LEFT JOIN blocks
-                        ON transactions.block = blocks.height
-                WHERE   received_notes.is_change != 1
-                ORDER   BY minedheight DESC, blocktimeinseconds DESC, id DESC
-                LIMIT   \(limit) OFFSET \(offset)
-                """
+    func find(in range: CompactBlockRange, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
+        let query = transactionsView
+            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc, ZcashTransaction.Overview.Column.id.desc)
+            .filter(
+                ZcashTransaction.Overview.Column.minedHeight >= BlockHeight(range.lowerBound) &&
+                ZcashTransaction.Overview.Column.minedHeight <= BlockHeight(range.upperBound)
             )
-            .map { bindings -> ConfirmedTransactionEntity in
-                guard let transaction = TransactionBuilder.createReceivedTransaction(from: bindings) else {
-                    throw TransactionRepositoryError.malformedTransaction
-                }
-                return transaction
-            }
+            .filterQueryFor(kind: kind)
+            .limit(limit)
+
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
 
-    func findAll(offset: Int = 0, limit: Int = Int.max) throws -> [ConfirmedTransactionEntity]? {
-        try dbProvider.connection()
-            .run(
-                """
-                SELECT
-                    transactions.id_tx          AS id,
-                    transactions.block          AS minedHeight,
-                    transactions.tx_index       AS transactionIndex,
-                    transactions.txid           AS rawTransactionId,
-                    transactions.expiry_height  AS expiryHeight,
-                    transactions.raw            AS raw,
-                    sent_notes.address          AS toAddress,
-                        CASE
-                            WHEN sent_notes.value IS NOT NULL THEN sent_notes.value
-                            ELSE received_notes.value
-                    end                          AS value,
-                        CASE
-                            WHEN sent_notes.memo IS NOT NULL THEN sent_notes.memo
-                            ELSE received_notes.memo
-                    end                          AS memo,
-                        CASE
-                            WHEN sent_notes.id_note IS NOT NULL THEN sent_notes.id_note
-                            ELSE received_notes.id_note
-                    end                          AS noteId,
-                    blocks.time                  AS blockTimeInSeconds
-                FROM  transactions
-                    LEFT JOIN received_notes
-                        ON transactions.id_tx = received_notes.tx
-                    LEFT JOIN sent_notes
-                        ON transactions.id_tx = sent_notes.tx
-                    LEFT JOIN blocks
-                        ON transactions.block = blocks.height
-                WHERE (sent_notes.address IS NULL AND received_notes.is_change != 1)
-                OR sent_notes.address IS NOT NULL
-                ORDER  BY ( minedheight IS NOT NULL ),
-                    minedheight DESC,
-                    blocktimeinseconds DESC,
-                    id DESC
-                LIMIT  \(limit) OFFSET \(offset)
-                """
+    func find(from transaction: ZcashTransaction.Overview, limit: Int, kind: TransactionKind) async throws -> [ZcashTransaction.Overview] {
+        guard
+            let transactionIndex = transaction.index,
+            let transactionBlockTime = transaction.blockTime
+        else { throw ZcashError.transactionRepositoryTransactionMissingRequiredFields }
+        
+        let query = transactionsView
+            .order(
+                (ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc, ZcashTransaction.Overview.Column.id.desc
             )
-            .compactMap { TransactionBuilder.createConfirmedTransaction(from: $0) }
+            .filter(
+                Int64(transactionBlockTime) > ZcashTransaction.Overview.Column.blockTime
+                && transactionIndex > ZcashTransaction.Overview.Column.index
+            )
+            .filterQueryFor(kind: kind)
+            .limit(limit)
+        
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+    }
+
+    func findReceived(offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview] {
+        let query = transactionsView
+            .filterQueryFor(kind: .received)
+            .order(ZcashTransaction.Overview.Column.id.desc, (ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc)
+            .limit(limit, offset: offset)
+
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+    }
+
+    func findSent(offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview] {
+        let query = transactionsView
+            .filterQueryFor(kind: .sent)
+            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc, ZcashTransaction.Overview.Column.id.desc)
+            .limit(limit, offset: offset)
+
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
     }
 
-    func findAll(from transaction: ConfirmedTransactionEntity?, limit: Int) throws -> [ConfirmedTransactionEntity]? {
-        guard let fromTransaction = transaction else {
-            return try findAll(offset: 0, limit: limit)
+    func findPendingTransactions(latestHeight: BlockHeight, offset: Int, limit: Int) async throws -> [ZcashTransaction.Overview] {
+        let query = transactionsView
+            .filterPendingFrom(latestHeight)
+            .order((ZcashTransaction.Overview.Column.minedHeight ?? BlockHeight.max).desc, ZcashTransaction.Overview.Column.id.desc)
+            .limit(limit, offset: offset)
+
+        return try execute(query) { try ZcashTransaction.Overview(row: $0) }
+    }
+
+    func findMemos(for transaction: ZcashTransaction.Overview) async throws -> [Memo] {
+        do {
+            return try await getTransactionOutputs(for: transaction.id)
+                .compactMap { $0.memo }
+        } catch {
+            throw ZcashError.transactionRepositoryFindMemos(error)
         }
+    }
 
-        return try dbProvider.connection()
-            .run(
-                """
-                SELECT transactions.id_tx        AS id,
-                    transactions.block           AS minedHeight,
-                    transactions.tx_index        AS transactionIndex,
-                    transactions.txid            AS rawTransactionId,
-                    transactions.expiry_height   AS expiryHeight,
-                    transactions.raw             AS raw,
-                    sent_notes.address           AS toAddress,
-                    CASE
-                        WHEN sent_notes.value IS NOT NULL THEN sent_notes.value
-                        ELSE received_notes.value
-                    end                          AS value,
-                    CASE
-                        WHEN sent_notes.memo IS NOT NULL THEN sent_notes.memo
-                        ELSE received_notes.memo
-                    end                          AS memo,
-                    CASE
-                        WHEN sent_notes.id_note IS NOT NULL THEN sent_notes.id_note
-                        ELSE received_notes.id_note
-                    end                          AS noteId,
-                    blocks.time                  AS blockTimeInSeconds
-                FROM    transactions
-                    LEFT JOIN received_notes
-                        ON transactions.id_tx = received_notes.tx
-                    LEFT JOIN sent_notes
-                        ON transactions.id_tx = sent_notes.tx
-                    LEFT JOIN blocks
-                        ON transactions.block = blocks.height
-                WHERE (\(fromTransaction.blockTimeInSeconds), \(fromTransaction.transactionIndex)) > (blocktimeinseconds, transactionIndex) AND
-                    (sent_notes.address IS NULL AND received_notes.is_change != 1)
-                    OR sent_notes.address IS NOT NULL
-                ORDER  BY ( minedheight IS NOT NULL ),
-                    minedheight DESC,
-                    blocktimeinseconds DESC,
-                    id DESC
-                LIMIT  \(limit)
-                """
-            )
-            .compactMap { TransactionBuilder.createConfirmedTransaction(from: $0) }
+    func getTransactionOutputs(for id: Int) async throws -> [ZcashTransaction.Output] {
+        let query = self.txOutputsView
+            .filter(ZcashTransaction.Output.Column.idTx == id)
+
+        return try execute(query) { try ZcashTransaction.Output(row: $0) }
     }
 
-    func findTransactions(in range: BlockRange, limit: Int = Int.max) throws -> [TransactionEntity]? {
-        try dbProvider.connection()
-            .run(
-                """
-                SELECT transactions.id_tx       AS id,
-                    transactions.block          AS minedHeight,
-                    transactions.tx_index       AS transactionIndex,
-                    transactions.txid           AS rawTransactionId,
-                    transactions.expiry_height  AS expiryHeight,
-                    transactions.raw            AS raw
-                FROM   transactions
-                WHERE  \(range.start.height) <= minedheight
-                AND minedheight <= \(range.end.height)
-                ORDER  BY ( minedheight IS NOT NULL ),
-                    minedheight ASC,
-                    id DESC
-                LIMIT  \(limit)
-                """
-            )
-            .compactMap { TransactionBuilder.createTransactionEntity(from: $0) }
+    func getRecipients(for id: Int) async throws -> [TransactionRecipient] {
+        try await getTransactionOutputs(for: id).map { $0.recipient }
     }
 
-    func findConfirmedTransactions(in range: BlockRange, offset: Int = 0, limit: Int = Int.max) throws -> [ConfirmedTransactionEntity]? {
-        try dbProvider.connection()
-            .run(
-                """
-                SELECT transactions.id_tx       AS id,
-                    transactions.block          AS minedHeight,
-                    transactions.tx_index       AS transactionIndex,
-                    transactions.txid           AS rawTransactionId,
-                    transactions.expiry_height  AS expiryHeight,
-                    transactions.raw            AS raw,
-                    sent_notes.address          AS toAddress,
-                    CASE
-                        WHEN sent_notes.value IS NOT NULL THEN sent_notes.value
-                        ELSE received_notes.value
-                    end                         AS value,
-                    CASE
-                        WHEN sent_notes.memo IS NOT NULL THEN sent_notes.memo
-                        ELSE received_notes.memo
-                    end                         AS memo,
-                    CASE
-                        WHEN sent_notes.id_note IS NOT NULL THEN sent_notes.id_note
-                        ELSE received_notes.id_note
-                    end                         AS noteId,
-                    blocks.time                 AS blockTimeInSeconds
-                FROM   transactions
-                    LEFT JOIN received_notes
-                        ON transactions.id_tx = received_notes.tx
-                    LEFT JOIN sent_notes
-                        ON transactions.id_tx = sent_notes.tx
-                    LEFT JOIN blocks
-                        ON transactions.block = blocks.height
-                WHERE (\(range.start.height) <= minedheight
-                    AND minedheight <= \(range.end.height)) AND
-                    (sent_notes.address IS NULL AND received_notes.is_change != 1)
-                    OR sent_notes.address IS NOT NULL
-                ORDER  BY ( minedheight IS NOT NULL ),
-                    minedheight DESC,
-                    blocktimeinseconds DESC,
-                    id DESC
-                LIMIT  \(limit) OFFSET \(offset)
-            """
-            )
-            .compactMap { TransactionBuilder.createConfirmedTransaction(from: $0) }
+    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 }
+        return entity
     }
 
-    func findConfirmedTransactionBy(rawId: Data) throws -> ConfirmedTransactionEntity? {
-        try dbProvider.connection()
-            .run(
-                """
-                    SELECT transactions.id_tx       AS id,
-                        transactions.block          AS minedHeight,
-                        transactions.tx_index       AS transactionIndex,
-                        transactions.txid           AS rawTransactionId,
-                        transactions.expiry_height  AS expiryHeight,
-                        transactions.raw            AS raw,
-                        sent_notes.address          AS toAddress,
-                        CASE
-                            WHEN sent_notes.value IS NOT NULL THEN sent_notes.value
-                            ELSE received_notes.value
-                        end                          AS value,
-                        CASE
-                            WHEN sent_notes.memo IS NOT NULL THEN sent_notes.memo
-                            ELSE received_notes.memo
-                        end                          AS memo,
-                        CASE
-                            WHEN sent_notes.id_note IS NOT NULL THEN sent_notes.id_note
-                            ELSE received_notes.id_note
-                        end                          AS noteId,
-                        blocks.time                  AS blockTimeInSeconds
-                    FROM    transactions
-                        LEFT JOIN received_notes
-                            ON transactions.id_tx = received_notes.tx
-                        LEFT JOIN sent_notes
-                            ON transactions.id_tx = sent_notes.tx
-                        LEFT JOIN blocks
-                            ON transactions.block = blocks.height
-                    WHERE minedheight >= 0
-                        AND rawTransactionId == \(Blob(bytes: rawId.bytes)) AND
-                            (sent_notes.address IS NULL AND received_notes.is_change != 1)
-                        OR sent_notes.address IS NOT NULL
-                    LIMIT 1
-                """
+    private func execute<Entity>(_ query: View, createEntity: (Row) throws -> Entity) throws -> [Entity] {
+        do {
+            let entities = try connection()
+                .prepare(query)
+                .map(createEntity)
+            
+            return entities
+        } catch {
+            if let error = error as? ZcashError {
+                throw error
+            } else {
+                throw ZcashError.transactionRepositoryQueryExecute(error)
+            }
+        }
+    }
+}
+
+private extension View {
+    func filterPendingFrom(_ latestHeight: BlockHeight) -> View {
+        filter(
+            // transaction has not expired
+            ZcashTransaction.Overview.Column.expiredUnmined == false &&
+            // transaction is "sent"
+            ZcashTransaction.Overview.Column.value < 0 &&
+            // transaction has not been mined yet OR
+            // it has been within the latest `defaultStaleTolerance` blocks
+            (
+                ZcashTransaction.Overview.Column.minedHeight == nil ||
+                ZcashTransaction.Overview.Column.minedHeight > (latestHeight - ZcashSDK.defaultStaleTolerance)
             )
-            .compactMap { TransactionBuilder.createConfirmedTransaction(from: $0) }
-            .first
+        )
+    }
+}
+
+private extension View {
+    func filterQueryFor(kind: TransactionKind) -> View {
+        switch kind {
+        case .all:
+            return self
+        case .sent:
+            return filter(ZcashTransaction.Overview.Column.value < 0)
+        case .received:
+            return filter(ZcashTransaction.Overview.Column.value >= 0)
+        }
     }
 }