react-native-zcash 0.3.4 → 0.4.0

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

@@ -0,0 +1,12 @@
+//
+//  ConnectorProvider.swift
+//  
+//
+//  Created by Francisco Gindre on 1/12/23.
+//
+import SQLite
+
+protocol ConnectionProvider {
+    func connection() throws -> Connection
+    func close()
+}

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

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

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

@@ -0,0 +1,39 @@
+//
+//  SimpleConnectionProvider.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/13/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+import SQLite
+
+class SimpleConnectionProvider: ConnectionProvider {
+    let path: String
+    let readonly: Bool
+    var db: Connection?
+    
+    init(path: String, readonly: Bool = false) {
+        self.path = path
+        self.readonly = readonly
+    }
+
+    /// throws ZcashError.simpleConnectionProvider
+    func connection() throws -> Connection {
+        guard let conn = db else {
+            do {
+                let conn = try Connection(path, readonly: readonly)
+                self.db = conn
+                return conn
+            } catch {
+                throw ZcashError.simpleConnectionProvider(error)
+            }
+        }
+        return conn
+    }
+
+    func close() {
+        self.db = nil
+    }
+}

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

@@ -0,0 +1,295 @@
+//
+//  CompactBlockDownload.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/16/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+private class BlockDownloaderStream {
+    let stream: AsyncThrowingStream<ZcashCompactBlock, Error>
+    var iterator: AsyncThrowingStream<ZcashCompactBlock, Error>.Iterator
+
+    init(stream: AsyncThrowingStream<ZcashCompactBlock, Error>) {
+        self.stream = stream
+        self.iterator = stream.makeAsyncIterator()
+    }
+
+    func nextBlock() async throws -> ZcashCompactBlock? {
+        return try await iterator.next()
+    }
+}
+
+/// Described object which can download blocks.
+protocol BlockDownloader {
+    /// Set max height to which blocks will be downloaded. If this is higher than upper bound of the whole range then upper bound of the whole range
+    /// is used as limit.
+    func setDownloadLimit(_ limit: BlockHeight) async
+
+    /// Set the range for the whole sync process. This method creates stream that is used to download blocks.
+    /// This method must be called before `startDownload()` is called. And it can't be called while download is in progress otherwise bad things
+    /// happen.
+    func setSyncRange(_ range: CompactBlockRange, batchSize: Int) async throws
+
+    /// Start downloading blocks.
+    ///
+    /// This methods creates new detached Task which is used to do the actual downloading.
+    ///
+    /// It's possible to call this methods anytime. If any download is already in progress nothing happens.
+    /// If the download limit is changed while download is in progress then blocks within new limit are downloaded automatically.
+    /// If the downlading finishes and then limit is changed you must call this method to start downloading.
+    ///
+    /// - Parameters:
+    ///   - maxBlockBufferSize: Number of blocks that is held in memory before blocks are written to disk.
+    func startDownload(maxBlockBufferSize: Int) async
+
+    /// Stop download. This method cancels Task used for downloading. And then it is waiting until internal `isDownloading` flag is set to `false`
+    func stopDownload() async
+
+    /// Waits until blocks from `range` are downloaded. This method does just the waiting. If `startDownload(maxBlockBufferSize:syncRange:)` isn't
+    /// called before then nothing is downloaded.
+    /// - Parameter range: Wait until blocks from `range` are downloaded.
+    func waitUntilRequestedBlocksAreDownloaded(in range: CompactBlockRange) async throws
+}
+
+actor BlockDownloaderImpl {
+    private enum Constants {
+        static let rebuildStreamAfterBatchesCount = 3
+    }
+
+    let service: LightWalletService
+    let downloaderService: BlockDownloaderService
+    let storage: CompactBlockRepository
+    let internalSyncProgress: InternalSyncProgress
+    let metrics: SDKMetrics
+    let logger: Logger
+
+    private var downloadStreamCreatedAtRange: CompactBlockRange = 0...0
+    private var downloadStream: BlockDownloaderStream?
+    private var syncRange: CompactBlockRange?
+    private var batchSize: Int?
+
+    private var downloadToHeight: BlockHeight = 0
+    private var isDownloading = false
+    private var task: Task<Void, Error>?
+    private var lastError: Error?
+
+    init(
+        service: LightWalletService,
+        downloaderService: BlockDownloaderService,
+        storage: CompactBlockRepository,
+        internalSyncProgress: InternalSyncProgress,
+        metrics: SDKMetrics,
+        logger: Logger
+    ) {
+        self.service = service
+        self.downloaderService = downloaderService
+        self.storage = storage
+        self.internalSyncProgress = internalSyncProgress
+        self.metrics = metrics
+        self.logger = logger
+    }
+
+    private func doDownload(maxBlockBufferSize: Int) async {
+        lastError = nil
+        do {
+            guard let batchSize = self.batchSize, let syncRange = self.syncRange else {
+                logger.error("Dont have downloadStream. Trying to download blocks before sync range is not set.")
+                throw ZcashError.blockDownloadSyncRangeNotSet
+            }
+
+            let latestDownloadedBlockHeight = await internalSyncProgress.load(.latestDownloadedBlockHeight)
+
+            let downloadFrom = max(syncRange.lowerBound, latestDownloadedBlockHeight + 1)
+            let downloadTo = min(downloadToHeight, syncRange.upperBound)
+
+            if downloadFrom > downloadTo {
+                logger.debug("""
+                Download from \(downloadFrom) is higher or same as dowload to \(downloadTo). All blocks are probably downloaded. Exiting.
+                """)
+                isDownloading = false
+                task = nil
+                return
+            }
+
+            let range = downloadFrom...downloadTo
+            let maxAmountBlocksDownloadedByStream = Constants.rebuildStreamAfterBatchesCount * batchSize
+            let createNewStream =
+                self.downloadStream == nil ||
+                range.lowerBound - downloadStreamCreatedAtRange.lowerBound >= maxAmountBlocksDownloadedByStream ||
+                downloadTo >= downloadStreamCreatedAtRange.upperBound
+
+            let downloadStream: BlockDownloaderStream
+            if let stream = self.downloadStream, !createNewStream {
+                downloadStream = stream
+            } else {
+                // In case that limit is larger than Constants.rebuildStreamAfterBatchesCount * batchSize we need to set upper bound of the range like
+                // this. This is not normal operational mode but something can request to download whole sync range at one go for example.
+                let streamRange = range.lowerBound...max(downloadToHeight, range.lowerBound + maxAmountBlocksDownloadedByStream)
+                logger.debug("Creating new stream for range \(streamRange.lowerBound)...\(streamRange.upperBound)")
+
+                downloadStreamCreatedAtRange = streamRange
+                let stream = service.blockStream(startHeight: streamRange.lowerBound, endHeight: streamRange.upperBound)
+                downloadStream = BlockDownloaderStream(stream: stream)
+                self.downloadStream = downloadStream
+            }
+
+            logger.debug("""
+            Starting downloading blocks.
+            syncRange:                   \(syncRange.lowerBound)...\(syncRange.upperBound)
+            downloadToHeight:            \(downloadToHeight)
+            latestDownloadedBlockHeight: \(latestDownloadedBlockHeight)
+            range:                       \(range.lowerBound)...\(range.upperBound)
+            """)
+
+            try await downloadAndStoreBlocks(
+                using: downloadStream,
+                at: range,
+                maxBlockBufferSize: maxBlockBufferSize,
+                totalProgressRange: syncRange
+            )
+
+            task = nil
+            if downloadToHeight > range.upperBound {
+                logger.debug("""
+                Finished downloading with range: \(range.lowerBound)...\(range.upperBound). Going to start new download.
+                range upper bound:      \(range.upperBound)
+                new downloadToHeight:   \(downloadToHeight)
+                """)
+                await startDownload(maxBlockBufferSize: maxBlockBufferSize)
+                logger.debug("finishing after start download")
+            } else {
+                logger.debug("Finished downloading with range: \(range.lowerBound)...\(range.upperBound)")
+                isDownloading = false
+            }
+        } catch {
+            if Task.isCancelled {
+                logger.debug("Blocks downloading canceled.")
+            } else {
+                lastError = error
+                logger.error("Blocks downloading failed: \(error)")
+            }
+            isDownloading = false
+            task = nil
+        }
+    }
+
+    private func compactBlocksDownloadStream(startHeight: BlockHeight, targetHeight: BlockHeight) async throws -> BlockDownloaderStream {
+        try Task.checkCancellation()
+        let stream = service.blockStream(startHeight: startHeight, endHeight: targetHeight)
+        return BlockDownloaderStream(stream: stream)
+    }
+
+    private func downloadAndStoreBlocks(
+        using stream: BlockDownloaderStream,
+        at range: CompactBlockRange,
+        maxBlockBufferSize: Int,
+        totalProgressRange: CompactBlockRange
+    ) async throws {
+        var buffer: [ZcashCompactBlock] = []
+        logger.debug("Downloading blocks in range: \(range.lowerBound)...\(range.upperBound)")
+
+        var startTime = Date()
+        var counter = 0
+        var lastDownloadedBlockHeight = -1
+
+        let pushMetrics: (BlockHeight, Date, Date) -> Void = { [metrics] lastDownloadedBlockHeight, startTime, finishTime in
+            metrics.pushProgressReport(
+                progress: BlockProgress(
+                    startHeight: totalProgressRange.lowerBound,
+                    targetHeight: totalProgressRange.upperBound,
+                    progressHeight: Int(lastDownloadedBlockHeight)
+                ),
+                start: startTime,
+                end: finishTime,
+                batchSize: maxBlockBufferSize,
+                operation: .downloadBlocks
+            )
+        }
+
+        for _ in stride(from: range.lowerBound, to: range.upperBound + 1, by: 1) {
+            try Task.checkCancellation()
+            guard let block = try await stream.nextBlock() else { break }
+
+            counter += 1
+            lastDownloadedBlockHeight = block.height
+
+            buffer.append(block)
+            if buffer.count >= maxBlockBufferSize {
+                let finishTime = Date()
+                try await storage.write(blocks: buffer)
+                await blocksBufferWritten(buffer)
+                buffer.removeAll(keepingCapacity: true)
+
+                pushMetrics(block.height, startTime, finishTime)
+
+                counter = 0
+                startTime = finishTime
+            }
+        }
+
+        if counter > 0 {
+            pushMetrics(lastDownloadedBlockHeight, startTime, Date())
+        }
+
+        try await storage.write(blocks: buffer)
+        await blocksBufferWritten(buffer)
+    }
+
+    private func blocksBufferWritten(_ buffer: [ZcashCompactBlock]) async {
+        guard let lastBlock = buffer.last else { return }
+        await internalSyncProgress.set(lastBlock.height, .latestDownloadedBlockHeight)
+    }
+}
+
+extension BlockDownloaderImpl: BlockDownloader {
+    func setDownloadLimit(_ limit: BlockHeight) async {
+        downloadToHeight = limit
+    }
+
+    func setSyncRange(_ range: CompactBlockRange, batchSize: Int) async throws {
+        downloadStream = nil
+        self.batchSize = batchSize
+        syncRange = range
+    }
+
+    func startDownload(maxBlockBufferSize: Int) async {
+        guard task == nil else {
+            logger.debug("Download already in progress.")
+            return
+        }
+        isDownloading = true
+        task = Task.detached() { [weak self] in
+            // Solve when self is nil, task should be niled.
+            await self?.doDownload(maxBlockBufferSize: maxBlockBufferSize)
+        }
+    }
+
+    func stopDownload() async {
+        task?.cancel()
+        task = nil
+        while isDownloading {
+            do {
+                try await Task.sleep(milliseconds: 10)
+            } catch {
+                break
+            }
+        }
+        downloadStream = nil
+    }
+
+    func waitUntilRequestedBlocksAreDownloaded(in range: CompactBlockRange) async throws {
+        logger.debug("Waiting until requested blocks are downloaded at \(range)")
+        var latestDownloadedBlock = await internalSyncProgress.load(.latestDownloadedBlockHeight)
+        while latestDownloadedBlock < range.upperBound {
+            if let error = lastError {
+                throw error
+            }
+            try await Task.sleep(milliseconds: 10)
+            latestDownloadedBlock = await internalSyncProgress.load(.latestDownloadedBlockHeight)
+        }
+        logger.debug("Waiting done. Blocks are downloaded at \(range)")
+    }
+}

package/ios/ZCashLightClientKit/Block/Download/BlockDownloaderService.swift

@@ -0,0 +1,117 @@
+//
+//  BlockDownloader.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 17/09/2019.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+enum BlockDownloaderServiceError: Error {
+    case timeout
+    case generalError(error: Error)
+}
+/**
+Represents what a compact block downloaded should provide to its clients
+*/
+protocol BlockDownloaderService {
+    var storage: CompactBlockRepository { get }
+
+    /**
+    Downloads and stores the given block range.
+    */
+    func downloadBlockRange(_ heightRange: CompactBlockRange) async throws
+
+    /**
+    Restore the download progress up to the given height.
+    */
+    func rewind(to height: BlockHeight) async throws
+
+    /**
+    Returns the height of the latest compact block stored locally.
+    BlockHeight.empty() if no blocks are stored yet
+    */
+    func lastDownloadedBlockHeight() async throws -> BlockHeight
+
+    /**
+    Returns the latest block height
+    */
+    func latestBlockHeight() async throws -> BlockHeight
+
+    /**
+    Gets the transaction for the Id given
+    - Parameter txId: Data representing the transaction Id
+    */
+    func fetchTransaction(txId: Data) async throws -> ZcashTransaction.Fetched
+
+    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>
+
+    func fetchUnspentTransactionOutputs(tAddresses: [String], startHeight: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error>
+    
+    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 BlockDownloaderServiceImpl {
+    let lightwalletService: LightWalletService
+    let storage: CompactBlockRepository
+    
+    init(service: LightWalletService, storage: CompactBlockRepository) {
+        self.lightwalletService = service
+        self.storage = storage
+    }
+}
+
+extension BlockDownloaderServiceImpl: BlockDownloaderService {
+    func closeConnection() {
+        lightwalletService.closeConnection()
+    }
+            
+    func fetchUnspentTransactionOutputs(
+        tAddresses: [String],
+        startHeight: BlockHeight
+    ) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
+        lightwalletService.fetchUTXOs(for: tAddresses, height: startHeight)
+    }
+    
+    func fetchUnspentTransactionOutputs(tAddress: String, startHeight: BlockHeight) -> AsyncThrowingStream<UnspentTransactionOutputEntity, Error> {
+        lightwalletService.fetchUTXOs(for: tAddress, height: startHeight)
+    }
+    
+    func latestBlockHeight() async throws -> BlockHeight {
+        try await lightwalletService.latestBlockHeight()
+    }
+    
+    func downloadBlockRange( _ heightRange: CompactBlockRange) async throws {
+        let stream: AsyncThrowingStream<ZcashCompactBlock, Error> = lightwalletService.blockRange(heightRange)
+        do {
+            var compactBlocks: [ZcashCompactBlock] = []
+            for try await compactBlock in stream {
+                compactBlocks.append(compactBlock)
+            }
+            try await self.storage.write(blocks: compactBlocks)
+        } catch {
+            throw ZcashError.blockDownloaderServiceDownloadBlockRange(error)
+        }
+    }
+
+    func rewind(to height: BlockHeight) async throws {
+        try await self.storage.rewind(to: height)
+    }
+
+    func lastDownloadedBlockHeight() async -> BlockHeight {
+        await self.storage.latestHeight()
+    }
+    
+    func fetchTransaction(txId: Data) async throws -> ZcashTransaction.Fetched {
+        try await lightwalletService.fetchTransaction(txId: txId)
+    }
+}

package/ios/ZCashLightClientKit/Block/Enhance/BlockEnhancer.swift

@@ -0,0 +1,123 @@
+//
+//  CompactBlockEnhancement.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 4/10/20.
+//
+
+import Foundation
+
+protocol BlockEnhancer {
+    func enhance(at range: CompactBlockRange, didEnhance: (EnhancementProgress) async -> Void) async throws -> [ZcashTransaction.Overview]?
+}
+
+struct BlockEnhancerImpl {
+    let blockDownloaderService: BlockDownloaderService
+    let internalSyncProgress: InternalSyncProgress
+    let rustBackend: ZcashRustBackendWelding
+    let transactionRepository: TransactionRepository
+    let metrics: SDKMetrics
+    let logger: Logger
+
+    private func enhance(transaction: ZcashTransaction.Overview) async throws -> ZcashTransaction.Overview {
+        logger.debug("Zoom.... Enhance... Tx: \(transaction.rawID.toHexStringTxId())")
+
+        let fetchedTransaction = try await blockDownloaderService.fetchTransaction(txId: transaction.rawID)
+
+        let transactionID = fetchedTransaction.rawID.toHexStringTxId()
+        let block = String(describing: transaction.minedHeight)
+        logger.debug("Decrypting and storing transaction id: \(transactionID) block: \(block)")
+
+        try await rustBackend.decryptAndStoreTransaction(
+            txBytes: fetchedTransaction.raw.bytes,
+            minedHeight: Int32(fetchedTransaction.minedHeight)
+        )
+
+        return try await transactionRepository.find(rawID: fetchedTransaction.rawID)
+    }
+}
+
+extension BlockEnhancerImpl: BlockEnhancer {
+    func enhance(at range: CompactBlockRange, didEnhance: (EnhancementProgress) async -> Void) async throws -> [ZcashTransaction.Overview]? {
+        try Task.checkCancellation()
+        
+        logger.debug("Started Enhancing range: \(range)")
+
+        var retries = 0
+        let maxRetries = 5
+        
+        // fetch transactions
+        do {
+            let startTime = Date()
+            let transactions = try await transactionRepository.find(in: range, limit: Int.max, kind: .all)
+
+            guard !transactions.isEmpty else {
+                await internalSyncProgress.set(range.upperBound, .latestEnhancedHeight)
+                logger.debug("no transactions detected on range: \(range.lowerBound)...\(range.upperBound)")
+                return nil
+            }
+
+            let chainTipHeight = try await blockDownloaderService.latestBlockHeight()
+
+            let newlyMinedLowerBound = chainTipHeight - ZcashSDK.expiryOffset
+
+            let newlyMinedRange = newlyMinedLowerBound...chainTipHeight
+
+            for index in 0 ..< transactions.count {
+                let transaction = transactions[index]
+                var retry = true
+                
+                while retry && retries < maxRetries {
+                    try Task.checkCancellation()
+                    do {
+                        let confirmedTx = try await enhance(transaction: transaction)
+                        retry = false
+                        
+                        let progress = EnhancementProgress(
+                            totalTransactions: transactions.count,
+                            enhancedTransactions: index + 1,
+                            lastFoundTransaction: confirmedTx,
+                            range: range,
+                            newlyMined: confirmedTx.isSentTransaction && newlyMinedRange.contains(confirmedTx.minedHeight ?? 0)
+                        )
+
+                        await didEnhance(progress)
+
+                        if let minedHeight = confirmedTx.minedHeight {
+                            await internalSyncProgress.set(minedHeight, .latestEnhancedHeight)
+                        }
+                    } catch {
+                        retries += 1
+                        logger.error("could not enhance txId \(transaction.rawID.toHexStringTxId()) - Error: \(error)")
+                        if retries > maxRetries {
+                            throw error
+                        }
+                    }
+                }
+            }
+            
+            metrics.pushProgressReport(
+                progress: BlockProgress(
+                    startHeight: range.lowerBound,
+                    targetHeight: range.upperBound,
+                    progressHeight: range.upperBound
+                ),
+                start: startTime,
+                end: Date(),
+                batchSize: range.count,
+                operation: .enhancement
+            )
+        } catch {
+            logger.error("error enhancing transactions! \(error)")
+            throw error
+        }
+
+        await internalSyncProgress.set(range.upperBound, .latestEnhancedHeight)
+        
+        if Task.isCancelled {
+            logger.debug("Warning: compactBlockEnhancement on range \(range) cancelled")
+        }
+
+        return (try? await transactionRepository.find(in: range, limit: Int.max, kind: .all))
+    }
+}