react-native-zcash 0.6.14 → 0.7.0

package/ios/ZCashLightClientKit/Metrics/SDKMetrics.swift

@@ -7,252 +7,138 @@
 
 import Foundation
 
-/// SDK's tool for the measurement of metrics.
-/// The barebone API of the `SDKMetrics` is all about turning it on/off, pushing new reports in and popping RAW data out.
-/// The processing of data is either left to the user of `SDKMetrics` or anybody can take an advantage of extension APIs
-/// providing useful structs and reports.
-///
-/// Usage:
-/// The `SDKMetrics` API has been designed so it has the lowest impact possible on the SDK itself.
-/// Reporting of the metrics is already in place but ignored until `enableMetrics()` is called. Once turned on, the data is collected
-/// and cumulated to the in memory structural storage until `disableMetrics()` is called.
-/// `disableMetrics()` also clears out the in memory storage.
-///
-/// To collect data and process it there are 2 ways:
-///
-/// 1.
-/// Get RAW data by calling either `popBlock` or `popAllBlockReports`. The post-processing of data is then delegated to the caller.
-///
-/// 2.
-/// Get cumulated data by using an extension APIs. For the summarized collection, call `cumulativeSummary()`.
-/// Sometimes, typically when you want to run several iterations, the `cumulateReportsAndStartNewSet()` automatically computes
-/// cumulativeSummary, stores it and starts to collect a new set. All summaries can be either processed by a caller,
-/// accessing the collection `cumulativeSummaries` directly or values can be merged into one final summary by calling `summarizedCumulativeReports()`.
-///
-/// We encourage you to check`SDKMetricsTests` and other tests in the Test/PerformanceTests/ folder.
-public class SDKMetrics {
-    public struct BlockMetricReport: Equatable {
-        public let batchSize: Int
-        public let startTime: TimeInterval
-        public let endTime: TimeInterval
-        public var duration: TimeInterval { endTime - startTime }
-    }
-    
-    public enum Operation {
-        case downloadBlocks
-        case scanBlocks
-        case enhancement
-        case fetchUTXOs
-    }
-    
-    public struct SyncReport: Equatable {
-        public let startTime: TimeInterval
-        public let endTime: TimeInterval
-        public var duration: TimeInterval { endTime - startTime }
-    }
-    
-    public var cumulativeSummaries: [CumulativeSummary] = []
-    public var syncReport: SyncReport?
-    var isEnabled = false
-    var reports: [Operation: [BlockMetricReport]] = [:]
+protocol SDKMetrics {
+    func cbpStart()
+    func actionStart(_ action: CBPState)
+    func actionDetail(_ detail: String, `for` action: CBPState)
+    func actionStop()
+    func logCBPOverviewReport(_ logger: Logger, walletSummary: WalletSummary?) async
+}
 
-    public init() { }
-    
-    /// `SDKMetrics` is disabled by default. Any pushed data are simply ignored until `enableMetrics()` is called.
-    public func enableMetrics() {
-        isEnabled = true
+final class SDKMetricsImpl: SDKMetrics {
+    public struct CBPStateMetricReport: Equatable {
+        static let zero = Self(runs: 0, startTime: 0, cummulativeTime: 0, maxTime: 0, avgTime: 0)
+        
+        var runs: Int
+        var startTime: TimeInterval
+        var cummulativeTime: TimeInterval
+        var minTime: TimeInterval = .infinity
+        var maxTime: TimeInterval
+        var avgTime: TimeInterval
+        
+        var details: [String] = []
     }
+
+    // Compact Block Processor Metrics
+    var syncs = 0
+    var cbpStartTime: TimeInterval = 0
+    var cbpOverview: [CBPState: CBPStateMetricReport] = [:]
+    var lastActionInRun: CBPState?
     
-    public func disableMetrics() {
-        isEnabled = false
-        clearAll()
+    public init() { }
+
+    func cbpStart() {
+        syncs += 1
+        cbpStartTime = Date().timeIntervalSince1970
+        
+        // reset of previous values
+        cbpOverview.removeAll()
     }
-    
-    /// `SDKMetrics` focuses deeply on sync process and metrics related to it. By default there are reports around
-    /// block operations like download, validate, etc. This method pushes data on a stack for the specific operation.
-    func pushProgressReport(
-        start: Date,
-        end: Date,
-        batchSize: Int,
-        operation: Operation
-    ) {
-        guard isEnabled else { return }
         
-        let blockMetricReport = BlockMetricReport(
-            batchSize: batchSize,
-            startTime: start.timeIntervalSinceReferenceDate,
-            endTime: end.timeIntervalSinceReferenceDate
-        )
+    func actionStart(_ action: CBPState) {
+        actionStop()
         
-        guard reports[operation] != nil else {
-            reports[operation] = [blockMetricReport]
-            return
+        lastActionInRun = action
+
+        var report = CBPStateMetricReport.zero
+
+        if let reportFound = cbpOverview[action] {
+            report = reportFound
         }
+
+        report.runs += 1
+        report.startTime = Date().timeIntervalSince1970
         
-        reports[operation]?.append(blockMetricReport)
+        cbpOverview[action] = report
     }
     
-    /// Block synchronisation consists of operations but the whole process is measured also, represented by
-    /// different struct `SyncReport`, missing specifics for the operations like batch size, etc.
-    /// Used for the total syncing time report in the first place.
-    func pushSyncReport(
-        start: Date,
-        end: Date
-    ) {
-        guard isEnabled else { return }
+    func actionDetail(_ detail: String, `for` action: CBPState) {
+        guard var report = cbpOverview[action] else {
+            return
+        }
         
-        let syncReport = SyncReport(
-            startTime: start.timeIntervalSinceReferenceDate,
-            endTime: end.timeIntervalSinceReferenceDate
-        )
+        report.details.append(detail)
         
-        self.syncReport = syncReport
+        cbpOverview[action] = report
     }
     
-    /// A method allowing users of the `SDKMetrics` to pop the RAW data out of the system. For the specific `operation`
-    /// with option to either leave data in the storage or flushing it out and start the next batch of collecting new ones.
-    public func popBlock(operation: Operation, flush: Bool = false) -> [BlockMetricReport]? {
-        defer {
-            if flush { clearReport(operation) }
+    func actionStop() {
+        guard let lastActionInRun else {
+            return
         }
         
-        return reports[operation]
-    }
-    
-    /// A method allowing users of the `SDKMetrics` to pop the RAW data out of the system. This time for all measured operations
-    /// with option to either leave data in the storage or flushing it out and start the next batch of collecting new ones.
-    public func popAllBlockReports(flush: Bool = false) -> [Operation: [BlockMetricReport]] {
-        defer {
-            if flush { clearAllBlockReports() }
+        guard var report = cbpOverview[lastActionInRun] else {
+            return
         }
-        
-        return reports
-    }
-    
-    func clearReport(_ operation: Operation) {
-        reports.removeValue(forKey: operation)
-    }
-        
-    func clearAllBlockReports() {
-        reports.removeAll()
-        cumulativeSummaries.removeAll()
-    }
-    
-    func clearAll() {
-        clearAllBlockReports()
-        syncReport = nil
-    }
-}
 
-/// This extension provides an API that provides the summary and accumulated reports.
-/// The RAW data can pulled out and be processed without this extension but we
-/// wanted to provide a way how to get essential summaries right from the SDK.
-extension SDKMetrics {
-    public struct CumulativeSummary: Equatable {
-        public let downloadedBlocksReport: ReportSummary?
-        public let scannedBlocksReport: ReportSummary?
-        public let enhancementReport: ReportSummary?
-        public let fetchUTXOsReport: ReportSummary?
-        public let totalSyncReport: ReportSummary?
-    }
-
-    public struct ReportSummary: Equatable {
-        public let minTime: TimeInterval
-        public let maxTime: TimeInterval
-        public let avgTime: TimeInterval
+        let endTime = Date().timeIntervalSince1970
+        let runTime = endTime - report.startTime
         
-        public static let zero = Self(minTime: 0, maxTime: 0, avgTime: 0)
-    }
-
-    /// This method takes all the RAW data and computes a `CumulativeSummary` for every `operation`
-    /// independently. A `ReportSummary` is the result per `operation`, providing min, max and avg times.
-    public func cumulativeSummary() -> CumulativeSummary {
-        let downloadReport = summaryFor(reports: reports[.downloadBlocks])
-        let scanReport = summaryFor(reports: reports[.scanBlocks])
-        let enhancementReport = summaryFor(reports: reports[.enhancement])
-        let fetchUTXOsReport = summaryFor(reports: reports[.fetchUTXOs])
-        var totalSyncReport: ReportSummary?
+        report.cummulativeTime += runTime
         
-        if let duration = syncReport?.duration {
-            totalSyncReport = ReportSummary(minTime: duration, maxTime: duration, avgTime: duration)
+        if runTime < report.minTime {
+            report.minTime = runTime
         }
-        
-        return CumulativeSummary(
-            downloadedBlocksReport: downloadReport,
-            scannedBlocksReport: scanReport,
-            enhancementReport: enhancementReport,
-            fetchUTXOsReport: fetchUTXOsReport,
-            totalSyncReport: totalSyncReport
-        )
-    }
-    
-    /// This method computes the `CumulativeSummary` for the RAW data already in the system, stores it
-    /// and leave room for collecting new RAW data. Typical use case is when some code is expected to run several times
-    /// and every run is expected to be a new data collection.
-    /// Usage of this API is then typically followed by calling `summarizedCumulativeReports()` which merges all stored
-    /// cumulative reports into one final report.
-    public func cumulateReportsAndStartNewSet() {
-        cumulativeSummaries.append(cumulativeSummary())
-        reports.removeAll()
-        syncReport = nil
-    }
 
-    /// This method takes all `CumulativeSummary` reports and merge them all together, providing
-    /// final `CumulativeSummary` per `operation`, ensuring right min and max values are in the place
-    /// as well as computes final avg time per `operation`.
-    public func summarizedCumulativeReports() -> CumulativeSummary? {
-        var finalSummary: CumulativeSummary?
-        
-        cumulativeSummaries.forEach { summary in
-            finalSummary = CumulativeSummary(
-                downloadedBlocksReport: accumulate(left: finalSummary?.downloadedBlocksReport, right: summary.downloadedBlocksReport),
-                scannedBlocksReport: accumulate(left: finalSummary?.scannedBlocksReport, right: summary.scannedBlocksReport),
-                enhancementReport: accumulate(left: finalSummary?.enhancementReport, right: summary.enhancementReport),
-                fetchUTXOsReport: accumulate(left: finalSummary?.fetchUTXOsReport, right: summary.fetchUTXOsReport),
-                totalSyncReport: accumulate(left: finalSummary?.totalSyncReport, right: summary.totalSyncReport)
-            )
+        if runTime > report.maxTime {
+            report.maxTime = runTime
         }
         
-        return finalSummary
+        if report.runs > 0 {
+            report.avgTime = report.cummulativeTime / Double(report.runs)
+        }
+
+        cbpOverview[lastActionInRun] = report
     }
     
-    /// Internal helper method that accumulates `ReportSummary` times.
-    func accumulate(left: ReportSummary?, right: ReportSummary?) -> ReportSummary? {
-        guard let left, let right else {
-            if let right {
-                return ReportSummary(
-                    minTime: right.minTime,
-                    maxTime: right.maxTime,
-                    avgTime: right.avgTime
-                )
-            }
-            return nil
-        }
-        
-        return ReportSummary(
-            minTime: min(left.minTime, right.minTime),
-            maxTime: max(left.maxTime, right.maxTime),
-            avgTime: (left.avgTime + right.avgTime) * 0.5
+    // swiftlint:disable string_concatenation
+    func logCBPOverviewReport(_ logger: Logger, walletSummary: WalletSummary?) async {
+        actionStop()
+
+        let accountBalance = walletSummary?.accountBalances[0]
+        logger.sync(
+            """
+            SYNC (\(syncs)) REPORT
+            finished in: \(Date().timeIntervalSince1970 - cbpStartTime)
+            verified balance: \(accountBalance?.saplingBalance.spendableValue.amount ?? 0)
+            total balance: \(accountBalance?.saplingBalance.total().amount ?? 0)
+            """
         )
-    }
 
-    /// Internal helper method that computes min, max and avg times for the `BlockMetricReport` collection.
-    func summaryFor(reports: [BlockMetricReport]?) -> ReportSummary? {
-        guard let reports, !reports.isEmpty else { return nil }
-        
-        var min: TimeInterval = 99999999.0
-        var max: TimeInterval = 0.0
-        var avg: TimeInterval = 0.0
+        try? await Task.sleep(nanoseconds: 100_000)
+
+        for action in cbpOverview {
 
-        reports.forEach { report in
-            let duration = report.duration
-            avg += duration
-            if duration > max { max = duration }
-            if duration < min { min = duration }
+            let report = action.value
+
+            var resText = """
+                action:             \(action.key)
+                runs:               \(report.runs)
+                cummulativeTime:    \(report.cummulativeTime)
+                minTime:            \(report.minTime)
+                maxTime:            \(report.maxTime)
+                avgTime:            \(report.avgTime)
+                """
+            
+            if !report.details.isEmpty {
+                resText += "\ndetails:\n"
+                
+                for detail in report.details {
+                    resText += "\t\(detail)\n"
+                }
+            }
+            
+            logger.sync(resText)
         }
-        // reports.count is guarded to never be a zero
-        avg /= TimeInterval(reports.count)
-        
-        return ReportSummary(minTime: min, maxTime: max, avgTime: avg)
     }
 }

package/ios/ZCashLightClientKit/Model/Proposal.swift

@@ -0,0 +1,45 @@
+//
+//  Proposal.swift
+//
+//
+//  Created by Jack Grigg on 20/02/2024.
+//
+
+import Foundation
+
+/// A data structure that describes a series of transactions to be created.
+public struct Proposal: Equatable {
+    let inner: FfiProposal
+
+    /// Returns the number of transactions that this proposal will create.
+    ///
+    /// This is equal to the number of `TransactionSubmitResult`s that will be returned
+    /// from `Synchronizer.createProposedTransactions`.
+    ///
+    /// Proposals always create at least one transaction.
+    public func transactionCount() -> Int {
+        inner.steps.count
+    }
+
+    /// Returns the total fee to be paid across all proposed transactions, in zatoshis.
+    public func totalFeeRequired() -> Zatoshi {
+        inner.steps.reduce(Zatoshi.zero) { acc, step in
+            acc + Zatoshi(Int64(step.balance.feeRequired))
+        }
+    }
+}
+
+public extension Proposal {
+    /// IMPORTANT: This function is for testing purposes only. It produces fake invalid
+    /// data that can be used to check UI elements, but will always produce an error when
+    /// passed to `Synchronizer.createProposedTransactions`. It should never be called in
+    /// production code.
+    static func testOnlyFakeProposal(totalFee: UInt64) -> Self {
+        var ffiProposal = FfiProposal()
+        var balance = FfiTransactionBalance()
+
+        balance.feeRequired = totalFee
+
+        return Self(inner: ffiProposal)
+    }
+}

package/ios/ZCashLightClientKit/Model/ScanSummary.swift

@@ -0,0 +1,14 @@
+//
+//  ScanSummary.swift
+//
+//
+//  Created by Jack Grigg on 26/01/2024.
+//
+
+import Foundation
+
+struct ScanSummary: Equatable {
+    let scannedRange: Range<BlockHeight>
+    let spentSaplingNoteCount: UInt64
+    let receivedSaplingNoteCount: UInt64
+}

package/ios/ZCashLightClientKit/Model/WalletSummary.swift

@@ -0,0 +1,58 @@
+//
+//  WalletSummary.swift
+//
+//
+//  Created by Jack Grigg on 06/09/2023.
+//
+
+import Foundation
+
+public struct PoolBalance: Equatable {
+    public let spendableValue: Zatoshi
+    public let changePendingConfirmation: Zatoshi
+    public let valuePendingSpendability: Zatoshi
+
+    static let zero = PoolBalance(spendableValue: .zero, changePendingConfirmation: .zero, valuePendingSpendability: .zero)
+
+    public func total() -> Zatoshi {
+        self.spendableValue + self.changePendingConfirmation + self.valuePendingSpendability
+    }
+}
+
+public struct AccountBalance: Equatable {
+    public let saplingBalance: PoolBalance
+    public let orchardBalance: PoolBalance
+    public let unshielded: Zatoshi
+    
+    static let zero = AccountBalance(saplingBalance: .zero, orchardBalance: .zero, unshielded: .zero)
+}
+
+struct ScanProgress: Equatable {
+    let numerator: UInt64
+    let denominator: UInt64
+    
+    func progress() throws -> Float {
+        guard denominator != 0 else {
+            // this shouldn't happen but if it does, we need to get notified by clients and work on a fix
+            throw ZcashError.rustScanProgressOutOfRange("\(numerator)/\(denominator)")
+        }
+
+        let value = Float(numerator) / Float(denominator)
+        
+        // this shouldn't happen but if it does, we need to get notified by clients and work on a fix
+        if value > 1.0 {
+            throw ZcashError.rustScanProgressOutOfRange("\(value)")
+        }
+
+        return value
+    }
+}
+
+struct WalletSummary: Equatable {
+    let accountBalances: [UInt32: AccountBalance]
+    let chainTipHeight: BlockHeight
+    let fullyScannedHeight: BlockHeight
+    let scanProgress: ScanProgress?
+    let nextSaplingSubtreeIndex: UInt32
+    let nextOrchardSubtreeIndex: UInt32
+}

package/ios/ZCashLightClientKit/Model/WalletTypes.swift

@@ -263,19 +263,3 @@ public enum Recipient: Equatable, StringEncoded {
         }
     }
 }
-
-public struct WalletBalance: Equatable {
-    public let verified: Zatoshi
-    public let total: Zatoshi
-    
-    public init(verified: Zatoshi, total: Zatoshi) {
-        self.verified = verified
-        self.total = total
-    }
-}
-
-public extension WalletBalance {
-    static var zero: WalletBalance {
-        Self(verified: .zero, total: .zero)
-    }
-}

package/ios/ZCashLightClientKit/Modules/Service/GRPC/LightWalletGRPCService.swift

@@ -223,14 +223,12 @@ extension LightWalletGRPCService: LightWalletService {
             do {
                 guard let reply = try await iterator.next() else { return nil }
                 return UTXO(
-                    id: nil,
                     address: reply.address,
                     prevoutTxId: reply.txid,
                     prevoutIndex: Int(reply.index),
                     script: reply.script,
                     valueZat: Int(reply.valueZat),
-                    height: Int(reply.height),
-                    spentInTx: nil
+                    height: Int(reply.height)
                 )
             } catch {
                 let serviceError = error.mapToServiceError()
@@ -278,6 +276,10 @@ extension LightWalletGRPCService: LightWalletService {
         }
     }
 
+    func getTreeState(_ id: BlockID) async throws -> TreeState {
+        try await compactTxStreamer.getTreeState(id)
+    }
+
     func closeConnection() {
         _ = channel.close()
     }