react-native-zcash 0.3.3 → 0.3.5

package/ios/ZCashLightClientKit/Block/DatabaseStorage/CompactBlockStorage.swift

@@ -0,0 +1,123 @@
+//
+//  CompactBlockStorage.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/13/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+import SQLite
+
+protocol ConnectionProvider {
+    func connection() throws -> Connection
+}
+
+class CompactBlockStorage: CompactBlockDAO {
+    var dbProvider: ConnectionProvider
+    
+    init(connectionProvider: ConnectionProvider) {
+        dbProvider = connectionProvider
+    }
+    
+    private func compactBlocksTable() -> Table {
+        Table("compactblocks")
+    }
+    private func heightColumn() -> Expression<Int64> {
+        Expression<Int64>("height")
+    }
+    private func dataColumn() -> Expression<Blob> {
+        Expression<Blob>("data")
+    }
+    func createTable() throws {
+        do {
+            let compactBlocks = compactBlocksTable()
+            let height = heightColumn()
+            let data = dataColumn()
+            
+            let db = try dbProvider.connection()
+         
+            try db.run(compactBlocks.create(ifNotExists: true) { table in
+                table.column(height, primaryKey: true)
+                table.column(data)
+            }
+            )
+            
+            try db.run(compactBlocks.createIndex(height, ifNotExists: true))
+        } catch {
+            throw StorageError.couldNotCreate
+        }
+    }
+    
+    func insert(_ block: ZcashCompactBlock) throws {
+        try dbProvider.connection().run(compactBlocksTable().insert(block))
+    }
+    
+    func insert(_ blocks: [ZcashCompactBlock]) throws {
+        let compactBlocks = compactBlocksTable()
+        let db = try dbProvider.connection()
+        try db.transaction(.immediate) {
+            for block in blocks {
+                try db.run(compactBlocks.insert(block))
+            }
+        }
+    }
+    
+    func latestBlockHeight() throws -> BlockHeight {
+        guard let maxHeight = try dbProvider.connection().scalar(compactBlocksTable().select(heightColumn().max)) else {
+            return BlockHeight.empty()
+        }
+        
+        guard let blockHeight = BlockHeight(exactly: maxHeight) else {
+            throw StorageError.operationFailed
+        }
+        
+        return blockHeight
+    }
+    
+    func rewind(to height: BlockHeight) throws {
+        try dbProvider.connection().run(compactBlocksTable().filter(heightColumn() >= Int64(height)).delete())
+    }
+}
+
+extension CompactBlockStorage: CompactBlockRepository {
+    func latestHeight() throws -> BlockHeight {
+        try latestBlockHeight()
+    }
+    
+    func latestHeight(result: @escaping (Swift.Result<BlockHeight, Error>) -> Void) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                result(.success(try self.latestBlockHeight()))
+            } catch {
+                result(.failure(error))
+            }
+        }
+    }
+    
+    func write(blocks: [ZcashCompactBlock]) throws {
+        try insert(blocks)
+    }
+    
+    func write(blocks: [ZcashCompactBlock], completion: ((Error?) -> Void)?) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                try self.insert(blocks)
+                completion?(nil)
+            } catch {
+                completion?(error)
+            }
+        }
+    }
+    
+    func rewind(to height: BlockHeight, completion: ((Error?) -> Void)?) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                try self.rewind(to: height)
+                completion?(nil)
+            } catch {
+                completion?(error)
+            }
+        }
+    }
+}

package/ios/ZCashLightClientKit/Block/DatabaseStorage/DatabaseMigrationManager.swift

@@ -0,0 +1,222 @@
+//
+//  DatabaseMigrationManager.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 3/31/21.
+//
+
+import Foundation
+import SQLite
+
+class MigrationManager {
+    enum DataDbMigrations: Int32 {
+        case none = 0
+        case version1 = 1
+    }
+    
+    enum CacheDbMigration: Int32 {
+        case none = 0
+    }
+    
+    enum PendingDbMigration: Int32 {
+        case none = 0
+    }
+
+    static let latestDataDbMigrationVersion: Int32 = DataDbMigrations.version1.rawValue
+    static let latestCacheDbMigrationVersion: Int32 = CacheDbMigration.none.rawValue
+    static let latestPendingDbMigrationVersion: Int32 = PendingDbMigration.none.rawValue
+    
+    var cacheDb: ConnectionProvider
+    var dataDb: ConnectionProvider
+    var pendingDb: ConnectionProvider
+    var network: NetworkType
+
+    init(
+        cacheDbConnection: ConnectionProvider,
+        dataDbConnection: ConnectionProvider,
+        pendingDbConnection: ConnectionProvider,
+        networkType: NetworkType
+    ) {
+        self.cacheDb = cacheDbConnection
+        self.dataDb = dataDbConnection
+        self.pendingDb = pendingDbConnection
+        self.network = networkType
+    }
+
+    func performMigration(uvks: [UnifiedViewingKey]) throws {
+        try migrateDataDb(uvks: uvks)
+        try migrateCacheDb()
+        try migratePendingDb()
+    }
+
+    func performVersion1Migration(viewingKeys: [UnifiedViewingKey]) throws {
+        LoggerProxy.debug("Starting migration version 1 from viewing Keys")
+        let db = try self.dataDb.connection()
+       
+        let placeholder = "deriveMe"
+        let migrationStatement =
+            """
+                BEGIN TRANSACTION;
+                PRAGMA foreign_keys = OFF;
+                DROP TABLE utxos;
+                CREATE TABLE IF NOT EXISTS utxos(
+                    id_utxo INTEGER PRIMARY KEY,
+                    address TEXT NOT NULL,
+                    prevout_txid BLOB NOT NULL,
+                    prevout_idx INTEGER NOT NULL,
+                    script BLOB NOT NULL,
+                    value_zat INTEGER NOT NULL,
+                    height INTEGER NOT NULL,
+                    spent_in_tx INTEGER,
+                    FOREIGN KEY (spent_in_tx) REFERENCES transactions(id_tx),
+                    CONSTRAINT tx_outpoint UNIQUE (prevout_txid, prevout_idx)
+                );
+
+                CREATE TABLE IF NOT EXISTS accounts_new (
+                    account INTEGER PRIMARY KEY,
+                    extfvk TEXT NOT NULL,
+                    address TEXT NOT NULL,
+                    transparent_address TEXT NOT NULL
+                );
+
+                INSERT INTO accounts_new SELECT account, extfvk, address, '\(placeholder)' FROM accounts;
+                DROP TABLE accounts;
+
+                ALTER TABLE accounts_new RENAME TO accounts;
+
+                PRAGMA user_version = 1;
+                PRAGMA foreign_keys = ON;
+                COMMIT TRANSACTION;
+            """
+        LoggerProxy.debug("db.execute(\"\(migrationStatement)\")")
+        try db.execute(migrationStatement)
+            
+        LoggerProxy.debug("db.run() succeeded")
+        
+        // derive transparent (shielding) addresses
+        let accountsDao = AccountSQDAO(dbProvider: self.dataDb)
+        
+        let accounts = try accountsDao.getAll()
+        
+        guard !accounts.isEmpty else {
+            LoggerProxy.debug("no existing accounts found while performing this migration")
+            return
+        }
+        
+        guard accounts.count == viewingKeys.count else {
+            let message = """
+                Number of accounts found and viewing keys provided don't match.
+                Found \(accounts.count) account(s) and there were \(viewingKeys.count) Viewing key(s) provided.
+                """
+            LoggerProxy.debug(message)
+            throw StorageError.migrationFailedWithMessage(message: message)
+        }
+
+        let derivationTool = DerivationTool(networkType: self.network)
+        
+        for tuple in zip(accounts, viewingKeys) {
+            let tAddr = try derivationTool.deriveTransparentAddressFromPublicKey(tuple.1.extpub)
+            var account = tuple.0
+            account.transparentAddress = tAddr
+            try accountsDao.update(account)
+        }
+        
+        // sanity check
+        guard try accountsDao.getAll().first(where: { $0.transparentAddress == placeholder }) == nil else {
+            LoggerProxy.error("Accounts Migration performed but the transparent addresses were not derived")
+            throw StorageError.migrationFailed(underlyingError: KeyDerivationErrors.unableToDerive)
+        }
+    }
+
+    func performVersion1Migration(_ seedBytes: [UInt8]) throws {
+        LoggerProxy.debug("Starting migration version 1")
+        
+        // derive transparent (shielding) addresses
+        let accountsDao = AccountSQDAO(dbProvider: self.dataDb)
+        
+        let accounts = try accountsDao.getAll()
+        
+        guard !accounts.isEmpty else {
+            LoggerProxy.debug("no existing accounts found while performing this migration")
+            return
+        }
+        
+        let derivationTool = DerivationTool(networkType: self.network)
+        
+        let uvks = try derivationTool.deriveUnifiedViewingKeysFromSeed(seedBytes, numberOfAccounts: accounts.count)
+        
+        try performVersion1Migration(viewingKeys: uvks)
+    }
+}
+
+private extension MigrationManager {
+    func migratePendingDb() throws {
+        let currentPendingDbVersion = try pendingDb.connection().getUserVersion()
+
+        LoggerProxy.debug(
+            "Attempting to perform migration for pending Db - currentVersion: \(currentPendingDbVersion)." +
+            "Latest version is: \(Self.latestPendingDbMigrationVersion)"
+        )
+
+        if currentPendingDbVersion < Self.latestPendingDbMigrationVersion {
+            // perform no migration just adjust the version number
+            try self.cacheDb.connection().setUserVersion(PendingDbMigration.none.rawValue)
+        } else {
+            LoggerProxy.debug("PendingDb Db - no migration needed")
+        }
+    }
+
+    func migrateCacheDb() throws {
+        let currentCacheDbVersion = try cacheDb.connection().getUserVersion()
+
+        LoggerProxy.debug(
+            "Attempting to perform migration for cache Db - currentVersion: \(currentCacheDbVersion)." +
+            "Latest version is: \(Self.latestCacheDbMigrationVersion)"
+        )
+
+        if currentCacheDbVersion < Self.latestCacheDbMigrationVersion {
+            // perform no migration just adjust the version number
+            try self.cacheDb.connection().setUserVersion(CacheDbMigration.none.rawValue)
+        } else {
+            LoggerProxy.debug("Cache Db - no migration needed")
+        }
+    }
+
+    func migrateDataDb(uvks: [UnifiedViewingKey]) throws {
+        let currentDataDbVersion = try dataDb.connection().getUserVersion()
+        LoggerProxy.debug(
+            "Attempting to perform migration for data Db - currentVersion: \(currentDataDbVersion)." +
+            "Latest version is: \(Self.latestDataDbMigrationVersion)"
+        )
+
+        if currentDataDbVersion < Self.latestDataDbMigrationVersion {
+            for dbVersion in (currentDataDbVersion + 1) ... Self.latestDataDbMigrationVersion {
+                guard let version = DataDbMigrations.init(rawValue: dbVersion) else {
+                    LoggerProxy.error("failed to determine migration version")
+                    throw StorageError.invalidMigrationVersion(version: dbVersion)
+                }
+                switch version {
+                case .version1:
+                    try performVersion1Migration(viewingKeys: uvks)
+                case .none:
+                    break
+                }
+            }
+        } else {
+            LoggerProxy.debug("Data Db - no migration needed")
+        }
+    }
+}
+
+extension Connection {
+    func getUserVersion() throws -> Int32 {
+        guard let version = try scalar("PRAGMA user_version") as? Int64 else {
+            return 0
+        }
+        return Int32(version)
+    }
+    
+    func setUserVersion(_ version: Int32) throws {
+        try run("PRAGMA user_version = \(version)")
+    }
+}

package/ios/ZCashLightClientKit/Block/DatabaseStorage/StorageError.swift

@@ -0,0 +1,22 @@
+//
+//  Storage.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/13/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+enum StorageError: Error {
+    case couldNotCreate
+    case openFailed
+    case closeFailed
+    case operationFailed
+    case updateFailed
+    case malformedEntity(fields: [String]?)
+    case transactionFailed(underlyingError: Error)
+    case invalidMigrationVersion(version: Int32)
+    case migrationFailed(underlyingError: Error)
+    case migrationFailedWithMessage(message: String)
+}

package/ios/ZCashLightClientKit/Block/DatabaseStorage/StorageManager.swift

@@ -0,0 +1,73 @@
+//
+//  SQLDatabase.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/13/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+import SQLite
+
+class StorageManager {
+    static var shared = StorageManager()
+    
+    private var readOnly: [URL: Connection] = [:]
+    private var readWrite: [URL: Connection] = [:]
+    
+    init() {}
+    
+    func connection(at url: URL, readOnly: Bool = false) throws -> Connection {
+        readOnly ? try readOnlyConnection(at: url) : try readWriteConnection(at: url)
+    }
+    
+    private func readOnlyConnection(at url: URL) throws -> Connection {
+        if let readOnlyConnection = readOnly[url] {
+            return readOnlyConnection
+        }
+        
+        let readOnlyConnection = try Connection.customConection(at: url)
+        readOnly[url] = readOnlyConnection
+
+        return readOnlyConnection
+    }
+    
+    private func readWriteConnection(at url: URL) throws -> Connection {
+        if let readWriteConnection = readWrite[url] {
+            return readWriteConnection
+        }
+        
+        let readWriteConnection = try Connection.customConection(at: url)
+        readWrite[url] = readWriteConnection
+
+        return readWriteConnection
+    }
+}
+
+private extension Connection {
+    static func customConection(at url: URL, readonly: Bool = false) throws -> Connection {
+        let conn = try Connection(url.absoluteString, readonly: readonly)
+        try conn.run("PRAGMA journal_mode = TRUNCATE;")
+        return conn
+    }
+}
+
+class SimpleConnectionProvider: ConnectionProvider {
+    var path: String
+    var readonly: Bool
+    var db: Connection?
+    
+    init(path: String, readonly: Bool = false) {
+        self.path = path
+        self.readonly = readonly
+    }
+
+    func connection() throws -> Connection {
+        guard let conn = db else {
+            let conn = try Connection(path, readonly: readonly)
+            self.db = conn
+            return conn
+        }
+        return conn
+    }
+}

package/ios/ZCashLightClientKit/Block/Downloader/BlockDownloader.swift

@@ -0,0 +1,240 @@
+//
+//  BlockDownloader.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 17/09/2019.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+enum CompactBlockDownloadError: Error {
+    case timeout
+    case generalError(error: Error)
+}
+/**
+Represents what a compact block downloaded should provide to its clients
+*/
+public protocol CompactBlockDownloading {
+    /**
+    Downloads and stores the given block range.
+    Non-Blocking
+    */
+    func downloadBlockRange(
+        _ heightRange: CompactBlockRange,
+        completion: @escaping (Error?) -> Void
+    )
+    
+    /**
+    Remove newer blocks and go back to the given height
+    - Parameters:
+        - height: the given height to rewind to
+        - completion: block to be executed after completing rewind
+    */
+    func rewind(to height: BlockHeight, completion: @escaping (Error?) -> Void)
+    
+    /**
+    returns the height of the latest compact block stored locally
+    BlockHeight.empty() if no blocks are stored yet
+    non-blocking
+    */
+    func lastDownloadedBlockHeight(result: @escaping (Result<BlockHeight, Error>) -> Void)
+    
+    /**
+    Returns the last height on the blockchain
+    Non-blocking
+    */
+    func latestBlockHeight(result: @escaping (Result<BlockHeight, Error>) -> Void)
+    
+    /**
+    Downloads and stores the given block range.
+    Blocking
+    */
+    func downloadBlockRange(_ range: CompactBlockRange) throws
+    
+    /**
+    Restore the download progress up to the given height.
+    */
+    func rewind(to height: BlockHeight) throws
+
+    /**
+    Returns the height of the latest compact block stored locally.
+    BlockHeight.empty() if no blocks are stored yet
+    Blocking
+    */
+    func lastDownloadedBlockHeight() throws -> BlockHeight
+    
+    /**
+    Returns the latest block height
+    Blocking
+    */
+    func latestBlockHeight() throws -> BlockHeight
+    
+    /**
+    Gets the transaction for the Id given
+    - Parameter txId: Data representing the transaction Id
+    - Returns: a transaction entity with the requested transaction
+    - Throws: An error if the fetch failed
+    */
+    func fetchTransaction(txId: Data) throws -> TransactionEntity
+    
+    /**
+    Gets the transaction for the Id given
+    - Parameter txId: Data representing the transaction Id
+    - Parameter result: a handler for the result of the operation
+    */
+    func fetchTransaction(txId: Data, result: @escaping (Result<TransactionEntity, Error>) -> Void)
+    
+    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight) throws -> [UnspentTransactionOutputEntity]
+    
+    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight, result: @escaping (Result<[UnspentTransactionOutputEntity], Error>) -> Void)
+    
+    func fetchUnspentTransactionOutputs(tAddresses: [String], startHeight: BlockHeight) throws -> [UnspentTransactionOutputEntity]
+    
+    func fetchUnspentTransactionOutputs(tAddresses: [String], startHeight: BlockHeight, result: @escaping (Result<[UnspentTransactionOutputEntity], Error>) -> Void)
+    
+    func closeConnection()
+}
+
+/**
+Serves as a source of compact blocks received from the light wallet server. Once started, it will use the given
+lightwallet service to request all the appropriate blocks and compact block store to persist them. By delegating to
+these dependencies, the downloader remains agnostic to the particular implementation of how to retrieve and store
+data; although, by default the SDK uses gRPC and SQL.
+- Property lightwalletService: the service used for requesting compact blocks
+- Property storage: responsible for persisting the compact blocks that are received
+*/
+class CompactBlockDownloader {
+    var lightwalletService: LightWalletService
+    private(set) var storage: CompactBlockRepository
+    
+    init(service: LightWalletService, storage: CompactBlockRepository) {
+        self.lightwalletService = service
+        self.storage = storage
+    }
+}
+
+extension CompactBlockDownloader: CompactBlockDownloading {
+    func closeConnection() {
+        lightwalletService.closeConnection()
+    }
+    
+    func fetchUnspentTransactionOutputs(tAddresses: [String], startHeight: BlockHeight) throws -> [UnspentTransactionOutputEntity] {
+        try lightwalletService.fetchUTXOs(for: tAddresses, height: startHeight)
+    }
+    
+    func fetchUnspentTransactionOutputs(
+        tAddresses: [String],
+        startHeight: BlockHeight,
+        result: @escaping (Result<[UnspentTransactionOutputEntity], Error>) -> Void
+    ) {
+        lightwalletService.fetchUTXOs(for: tAddresses, height: startHeight) { fetchResult in
+            switch fetchResult {
+            case .success(let utxos):
+                result(.success(utxos))
+            case .failure(let error):
+                result(.failure(error))
+            }
+        }
+    }
+    
+    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight) throws -> [UnspentTransactionOutputEntity] {
+        try lightwalletService.fetchUTXOs(for: tAddress, height: startHeight)
+    }
+    
+    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight, result: @escaping (Result<[UnspentTransactionOutputEntity], Error>) -> Void) {
+        lightwalletService.fetchUTXOs(for: tAddress, height: startHeight) { fetchResult in
+            switch fetchResult {
+            case .success(let utxos):
+                result(.success(utxos))
+            case .failure(let error):
+                result(.failure(error))
+            }
+        }
+    }
+    
+    func latestBlockHeight(result: @escaping (Result<BlockHeight, Error>) -> Void) {
+        lightwalletService.latestBlockHeight { fetchResult in
+            switch fetchResult {
+            case .failure(let error):
+                result(.failure(error))
+            case .success(let height):
+                result(.success(height))
+            }
+        }
+    }
+    
+    func latestBlockHeight() throws -> BlockHeight {
+        try lightwalletService.latestBlockHeight()
+    }
+    
+    /**
+    Downloads and stores the given block range.
+    Non-Blocking
+    */
+    func downloadBlockRange(
+        _ heightRange: CompactBlockRange,
+        completion: @escaping (Error?) -> Void
+    ) {
+        lightwalletService.blockRange(heightRange) { [weak self] result in
+            guard let self = self else {
+                return
+            }
+            
+            switch result {
+            case .failure(let error):
+                completion(error)
+            case .success(let compactBlocks):
+                self.storage.write(blocks: compactBlocks) { storeError in
+                    completion(storeError)
+                }
+            }
+        }
+    }
+    
+    func downloadBlockRange(_ range: CompactBlockRange) throws {
+        let blocks = try lightwalletService.blockRange(range)
+        try storage.write(blocks: blocks)
+    }
+    
+    func rewind(to height: BlockHeight, completion: @escaping (Error?) -> Void) {
+        storage.rewind(to: height) { e in
+            completion(e)
+        }
+    }
+    
+    func lastDownloadedBlockHeight(result: @escaping (Result<BlockHeight, Error>) -> Void) {
+        storage.latestHeight { heightResult in
+            switch heightResult {
+            case .failure(let e):
+                result(.failure(CompactBlockDownloadError.generalError(error: e)))
+                return
+            case .success(let height):
+                result(.success(height))
+            }
+        }
+    }
+    
+    func rewind(to height: BlockHeight) throws {
+        try self.storage.rewind(to: height)
+    }
+    
+    func lastDownloadedBlockHeight() throws -> BlockHeight {
+        try self.storage.latestHeight()
+    }
+    
+    func fetchTransaction(txId: Data) throws -> TransactionEntity {
+        try lightwalletService.fetchTransaction(txId: txId)
+    }
+    
+    func fetchTransaction(txId: Data, result: @escaping (Result<TransactionEntity, Error>) -> Void) {
+        lightwalletService.fetchTransaction(txId: txId) { txResult in
+            switch txResult {
+            case .failure(let error):
+                result(.failure(error))
+            case .success(let transaction):
+                result(.success(transaction))
+            }
+        }
+    }
+}