react-native-zcash 0.8.1 → 0.9.0

package/ios/ZCashLightClientKit/Synchronizer/Dependencies.swift

@@ -14,8 +14,7 @@ enum Dependencies {
         alias: ZcashSynchronizerAlias,
         networkType: NetworkType,
         endpoint: LightWalletEndpoint,
-        loggingPolicy: Initializer.LoggingPolicy = .default(.debug),
-        enableBackendTracing: Bool = false
+        loggingPolicy: Initializer.LoggingPolicy = .default(.debug)
     ) {
         container.register(type: CheckpointSource.self, isSingleton: true) { _ in
             CheckpointSourceFactory.fromBundle(for: networkType)
@@ -35,6 +34,36 @@ enum Dependencies {
             return logger
         }
 
+        let rustLogging: RustLogging
+        switch loggingPolicy {
+        case .default(let logLevel):
+            switch logLevel {
+            case .debug:
+                rustLogging = RustLogging.debug
+            case .info, .event:
+                rustLogging = RustLogging.info
+            case .warning:
+                rustLogging = RustLogging.warn
+            case .error:
+                rustLogging = RustLogging.error
+            }
+        case .custom(let logger):
+            switch logger.maxLogLevel() {
+            case .debug:
+                rustLogging = RustLogging.debug
+            case .info, .event:
+                rustLogging = RustLogging.info
+            case .warning:
+                rustLogging = RustLogging.warn
+            case .error:
+                rustLogging = RustLogging.error
+            case .none:
+                rustLogging = RustLogging.off
+            }
+        case .noLogging:
+            rustLogging = RustLogging.off
+        }
+
         container.register(type: ZcashRustBackendWelding.self, isSingleton: true) { _ in
             ZcashRustBackend(
                 dbData: urls.dataDbURL,
@@ -42,7 +71,7 @@ enum Dependencies {
                 spendParamsPath: urls.spendParamsURL,
                 outputParamsPath: urls.outputParamsURL,
                 networkType: networkType,
-                enableTracing: enableBackendTracing
+                logLevel: rustLogging
             )
         }
 
@@ -96,6 +125,25 @@ enum Dependencies {
         container.register(type: ZcashFileManager.self, isSingleton: true) { _ in
             FileManager.default
         }
+        
+        container.register(type: TransactionEncoder.self, isSingleton: true) { di in
+            let service = di.resolve(LightWalletService.self)
+            let logger = di.resolve(Logger.self)
+            let transactionRepository = di.resolve(TransactionRepository.self)
+            let rustBackend = di.resolve(ZcashRustBackendWelding.self)
+
+            return WalletTransactionEncoder(
+                rustBackend: rustBackend,
+                dataDb: urls.dataDbURL,
+                fsBlockDbRoot: urls.fsBlockDbRoot,
+                service: service,
+                repository: transactionRepository,
+                outputParams: urls.outputParamsURL,
+                spendParams: urls.spendParamsURL,
+                networkType: networkType,
+                logger: logger
+            )
+        }
     }
     
     static func setupCompactBlockProcessor(
@@ -145,6 +193,7 @@ enum Dependencies {
             let rustBackend = di.resolve(ZcashRustBackendWelding.self)
             let transactionRepository = di.resolve(TransactionRepository.self)
             let metrics = di.resolve(SDKMetrics.self)
+            let service = di.resolve(LightWalletService.self)
             let logger = di.resolve(Logger.self)
 
             return BlockEnhancerImpl(
@@ -152,6 +201,7 @@ enum Dependencies {
                 rustBackend: rustBackend,
                 transactionRepository: transactionRepository,
                 metrics: metrics,
+                service: service,
                 logger: logger
             )
         }

package/ios/ZCashLightClientKit/Synchronizer/SDKSynchronizer.swift

@@ -12,7 +12,6 @@ import Combine
 /// Synchronizer implementation for UIKit and iOS 13+
 // swiftlint:disable type_body_length
 public class SDKSynchronizer: Synchronizer {
-    
     public var alias: ZcashSynchronizerAlias { initializer.alias }
 
     private lazy var streamsUpdateQueue = { DispatchQueue(label: "streamsUpdateQueue_\(initializer.alias.description)") }()
@@ -23,8 +22,12 @@ public class SDKSynchronizer: Synchronizer {
     private let eventSubject = PassthroughSubject<SynchronizerEvent, Never>()
     public var eventStream: AnyPublisher<SynchronizerEvent, Never> { eventSubject.eraseToAnyPublisher() }
 
+    private let exchangeRateUSDSubject = CurrentValueSubject<FiatCurrencyResult?, Never>(nil)
+    public var exchangeRateUSDStream: AnyPublisher<FiatCurrencyResult?, Never> { exchangeRateUSDSubject.eraseToAnyPublisher() }
+    
     let metrics: SDKMetrics
     public let logger: Logger
+    var tor: TorClient?
 
     // Don't read this variable directly. Use `status` instead. And don't update this variable directly use `updateStatus()` methods instead.
     private var underlyingStatus: GenericActor<InternalSyncStatus>
@@ -83,12 +86,14 @@ public class SDKSynchronizer: Synchronizer {
         self.syncSession = SyncSession(.nullID)
         self.syncSessionTicker = syncSessionTicker
         self.latestBlocksDataProvider = initializer.container.resolve(LatestBlocksDataProvider.self)
-        
+
         initializer.lightWalletService.connectionStateChange = { [weak self] oldState, newState in
             self?.connectivityStateChanged(oldState: oldState, newState: newState)
         }
 
-        Task(priority: .high) { [weak self] in await self?.subscribeToProcessorEvents(blockProcessor) }
+        Task(priority: .high) { [weak self] in
+            await self?.subscribeToProcessorEvents(blockProcessor)
+        }
     }
 
     deinit {
@@ -300,9 +305,9 @@ public class SDKSynchronizer: Synchronizer {
         do {
             try throwIfUnprepared()
             return try await transactionEncoder.proposeFulfillingPaymentFromURI(
-               uri,
-               accountIndex: accountIndex
-           )
+                uri,
+                accountIndex: accountIndex
+            )
         } catch ZcashError.rustCreateToAddress(let error) {
             throw ZcashError.rustProposeTransferFromURI(error)
         } catch {
@@ -480,8 +485,12 @@ public class SDKSynchronizer: Synchronizer {
         PagedTransactionRepositoryBuilder.build(initializer: initializer, kind: .all)
     }
 
+    public func getMemos(for rawID: Data) async throws -> [Memo] {
+        return try await transactionRepository.findMemos(for: rawID)
+    }
+
     public func getMemos(for transaction: ZcashTransaction.Overview) async throws -> [Memo] {
-        return try await transactionRepository.findMemos(for: transaction)
+        return try await transactionRepository.findMemos(for: transaction.rawID)
     }
 
     public func getRecipients(for transaction: ZcashTransaction.Overview) async -> [TransactionRecipient] {
@@ -505,6 +514,41 @@ public class SDKSynchronizer: Synchronizer {
         try await initializer.rustBackend.getWalletSummary()?.accountBalances[UInt32(accountIndex)]
     }
 
+    /// Fetches the latest ZEC-USD exchange rate.
+    public func refreshExchangeRateUSD() {
+        // ignore refresh request when one is already in flight
+        if let latestState = tor?.cachedFiatCurrencyResult?.state, latestState == .fetching {
+            return
+        }
+        
+        // broadcast cached value but update the state
+        if let cachedFiatCurrencyResult = tor?.cachedFiatCurrencyResult {
+            var fetchingState = cachedFiatCurrencyResult
+            fetchingState.state = .fetching
+            tor?.cachedFiatCurrencyResult = fetchingState
+            
+            exchangeRateUSDSubject.send(fetchingState)
+        }
+
+        Task {
+            do {
+                if tor == nil {
+                    logger.info("Bootstrapping Tor client for fetching exchange rates")
+                    tor = try await TorClient(torDir: initializer.torDirURL)
+                }
+                // broadcast new value in case of success
+                exchangeRateUSDSubject.send(try await tor?.getExchangeRateUSD())
+            } catch {
+                // broadcast cached value but update the state
+                var errorState = tor?.cachedFiatCurrencyResult
+                errorState?.state = .error
+                tor?.cachedFiatCurrencyResult = errorState
+
+                exchangeRateUSDSubject.send(errorState)
+            }
+        }
+    }
+
     public func getUnifiedAddress(accountIndex: Int) async throws -> UnifiedAddress {
         try await blockProcessor.getUnifiedAddress(accountIndex: accountIndex)
     }
@@ -608,6 +652,191 @@ public class SDKSynchronizer: Synchronizer {
         try await initializer.rustBackend.isSeedRelevantToAnyDerivedAccount(seed: seed)
     }
 
+    /// Takes the list of endpoints and runs it through a series of checks to evaluate its performance.
+    /// - Parameters:
+    ///    - endpoints: Array of endpoints to evaluate.
+    ///    - latencyThresholdMillis: The mean latency of `getInfo` and `getTheLatestHeight` calls must be below this threshold. The default is 300 ms.
+    ///    - fetchThresholdSeconds: The time to download `nBlocksToFetch` blocks from the stream must be below this threshold. The default is 60 seconds.
+    ///    - nBlocksToFetch: The number of blocks expected to be downloaded from the stream, with the time compared to `fetchThresholdSeconds`. The default is 100.
+    ///    - kServers: The expected number of endpoints in the output. The default is 3.
+    ///    - network: Mainnet or testnet. The default is mainnet.
+    public func evaluateBestOf(
+        endpoints: [LightWalletEndpoint],
+        latencyThresholdMillis: Double = 300.0,
+        fetchThresholdSeconds: Double = 60.0,
+        nBlocksToFetch: UInt64 = 100,
+        kServers: Int = 3,
+        network: NetworkType = .mainnet
+    ) async -> [LightWalletEndpoint] {
+        struct Service {
+            let originalEndpoint: LightWalletEndpoint
+            let service: LightWalletGRPCService
+            let url: String
+        }
+        
+        struct CheckResult {
+            let id: String
+            let info: LightWalletdInfo?
+            let getInfoTime: TimeInterval
+            let latestBlockHeight: BlockHeight?
+            let latestBlockHeightTime: TimeInterval
+            let mean: TimeInterval
+            let service: Service
+            var blockTime: TimeInterval
+        }
+        
+        // Initialize services for the endpoints
+        let services = endpoints.map {
+            Service(
+                originalEndpoint: $0,
+                service: LightWalletGRPCService(
+                    host: $0.host,
+                    port: $0.port,
+                    secure: $0.secure,
+                    singleCallTimeout: 5000,
+                    streamingCallTimeout: Int64(fetchThresholdSeconds) * 1000
+                ),
+                url: "\($0.host):\($0.port)"
+            )
+        }
+
+        // Parallel part
+        var checkResults: [String: CheckResult] = [:]
+        
+        await withTaskGroup(of: CheckResult.self) { group in
+            for service in services {
+                group.addTask {
+                    let startTime = Date().timeIntervalSince1970
+                    let info = try? await service.service.getInfo()
+                    let markTime = Date().timeIntervalSince1970
+                    let latestBlockHeight = try? await service.service.latestBlockHeight()
+                    let endTime = Date().timeIntervalSince1970
+
+                    let getInfoTime = markTime - startTime
+                    let latestBlockHeightTime = endTime - markTime
+                    let mean = (getInfoTime + latestBlockHeightTime) / 2
+
+                    return CheckResult(
+                        id: service.url,
+                        info: info,
+                        getInfoTime: getInfoTime,
+                        latestBlockHeight: latestBlockHeight,
+                        latestBlockHeightTime: latestBlockHeightTime,
+                        mean: mean,
+                        service: service,
+                        blockTime: 0
+                    )
+                }
+            }
+            
+            var tmpResults: [String: CheckResult] = [:]
+            
+            for await result in group {
+                // rule out results where calls failed
+                guard let info = result.info, result.latestBlockHeight != nil else {
+                    continue
+                }
+                
+                // rule out if mismatch of networks
+                guard (info.chainName == "main" && network == .mainnet) 
+                    || (info.chainName == "test" && network == .testnet) else {
+                    continue
+                }
+                
+                // rule out mismatch of consensus branch IDs
+                guard let localBranchID = await blockProcessor.consensusBranchIdFor(Int32(info.blockHeight)) else {
+                    continue
+                }
+
+                guard let remoteBranchID = ConsensusBranchID.fromString(info.consensusBranchID) else {
+                    continue
+                }
+                
+                guard remoteBranchID == localBranchID else {
+                    continue
+                }
+
+                // Rule out servers that are syncing, stuck, or probably on the wrong fork.
+                // To avoid falsely ruling out all servers this can only be a very loose check
+                // (i.e. `ZcashSDK.syncedThresholdBlocks` should not be too small),
+                // because `info.estimatedHeight` may be quite inaccurate.
+                guard info.blockHeight + ZcashSDK.syncedThresholdBlocks >= info.estimatedHeight else {
+                    continue
+                }
+                
+                tmpResults[result.id] = result
+            }
+
+            // rule out all means above latencyThreshold
+            let underThreshold = tmpResults.compactMap {
+                $0.value.mean < (latencyThresholdMillis / 1000.0) ? $0 : nil
+            }
+
+            // sort the server responses by mean
+            let sortedUnderThreshold = underThreshold.sorted {
+                $0.value.mean < $1.value.mean
+            }
+
+            // retain only k servers
+            let sortedUnderThresholdKOnly = sortedUnderThreshold.prefix(3)
+
+            sortedUnderThresholdKOnly.forEach {
+                checkResults[$0.key] = $0.value
+            }
+        }
+
+        // Sequential part
+        var blockResults: [String: CheckResult] = [:]
+
+        for serviceDict in checkResults {
+            guard let info = serviceDict.value.info else {
+                continue
+            }
+            
+            let service = serviceDict.value.service
+            
+            guard info.blockHeight >= nBlocksToFetch else {
+                continue
+            }
+            
+            let stream = service.service.blockStream(startHeight: BlockHeight(info.blockHeight - nBlocksToFetch), endHeight: BlockHeight(info.blockHeight))
+            
+            do {
+                let startTime = Date().timeIntervalSince1970
+                var endTime = startTime
+                for try await _ in stream {
+                    endTime = Date().timeIntervalSince1970
+                    if endTime - startTime >= fetchThresholdSeconds {
+                        break
+                    }
+                }
+
+                let blockTime = endTime - startTime
+
+                // rule out servers that can't fetch `nBlocksToFetch` blocks under fetchThresholdSeconds
+                if blockTime < fetchThresholdSeconds {
+                    var value = serviceDict.value
+                    value.blockTime = blockTime
+                    
+                    blockResults[serviceDict.key] = value
+                }
+            } catch {
+                continue
+            }
+        }
+        
+        // return what's left
+        let sortedServers = blockResults.sorted {
+            $0.value.blockTime < $1.value.blockTime
+        }
+
+        let finalResult = sortedServers.map {
+            $0.value.service.originalEndpoint
+        }
+
+        return finalResult
+    }
+    
     // MARK: Server switch
 
     public func switchTo(endpoint: LightWalletEndpoint) async throws {

package/ios/ZCashLightClientKit/Synchronizer.swift

@@ -101,6 +101,9 @@ public protocol Synchronizer: AnyObject {
     /// This stream is backed by `PassthroughSubject`. Check `SynchronizerEvent` to see which events may be emitted.
     var eventStream: AnyPublisher<SynchronizerEvent, Never> { get }
 
+    /// This stream emits the latest known USD/ZEC exchange rate, paired with the time it was queried. See `FiatCurrencyResult`.
+    var exchangeRateUSDStream: AnyPublisher<FiatCurrencyResult?, Never> { get }
+    
     /// Initialize the wallet. The ZIP-32 seed bytes can optionally be passed to perform
     /// database migrations. most of the times the seed won't be needed. If they do and are
     /// not provided this will fail with `InitializationResult.seedRequired`. It could
@@ -263,6 +266,11 @@ public protocol Synchronizer: AnyObject {
     /// - Parameter kind: Transaction Kind expected from this PaginatedTransactionRepository
     func paginatedTransactions(of kind: TransactionKind) -> PaginatedTransactionRepository
 
+    /// Get all memos for `transaction.rawID`.
+    ///
+    // sourcery: mockedName="getMemosForRawID"
+    func getMemos(for rawID: Data) async throws -> [Memo]
+
     /// Get all memos for `transaction`.
     ///
     // sourcery: mockedName="getMemosForClearedTransaction"
@@ -304,6 +312,9 @@ public protocol Synchronizer: AnyObject {
     /// - Returns: `AccountBalance`, struct that holds sapling and unshielded balances or `nil` when no account is associated with `accountIndex`
     func getAccountBalance(accountIndex: Int) async throws -> AccountBalance?
 
+    /// Fetches the latest ZEC-USD exchange rate and updates `exchangeRateUSDSubject`.
+    func refreshExchangeRateUSD()
+
     /// Rescans the known blocks with the current keys.
     ///
     /// `rewind(policy:)` can be called anytime. If the sync process is in progress then it is stopped first. In this case, it make some significant
@@ -356,6 +367,23 @@ public protocol Synchronizer: AnyObject {
     ///
     /// - parameter seed: byte array of the seed
     func isSeedRelevantToAnyDerivedAccount(seed: [UInt8]) async throws -> Bool
+    
+    /// Takes the list of endpoints and runs it through a series of checks to evaluate its performance.
+    /// - Parameters:
+    ///    - endpoints: Array of endpoints to evaluate.
+    ///    - latencyThresholdMillis: The mean latency of `getInfo` and `getTheLatestHeight` calls must be below this threshold. The default is 300 ms.
+    ///    - fetchThresholdSeconds: The time to download `nBlocksToFetch` blocks from the stream must be below this threshold. The default is 60 seconds.
+    ///    - nBlocksToFetch: The number of blocks expected to be downloaded from the stream, with the time compared to `fetchThresholdSeconds`. The default is 100.
+    ///    - kServers: The expected number of endpoints in the output. The default is 3.
+    ///    - network: Mainnet or testnet. The default is mainnet.
+    func evaluateBestOf(
+        endpoints: [LightWalletEndpoint],
+        latencyThresholdMillis: Double,
+        fetchThresholdSeconds: Double,
+        nBlocksToFetch: UInt64,
+        kServers: Int,
+        network: NetworkType
+    ) async -> [LightWalletEndpoint]
 }
 
 public enum SyncStatus: Equatable {

package/ios/ZCashLightClientKit/Tool/DerivationTool.swift

@@ -108,15 +108,29 @@ extension DerivationTool: KeyValidation {
     }
 
     public func isValidUnifiedAddress(_ unifiedAddress: String) -> Bool {
-        backend.isValidUnifiedAddress(unifiedAddress)
+        DerivationTool.getAddressMetadata(unifiedAddress).map {
+            $0.networkType == backend.networkType && $0.addressType == AddressType.unified
+        } ?? false
     }
-    
+
     public func isValidTransparentAddress(_ tAddress: String) -> Bool {
-        backend.isValidTransparentAddress(tAddress)
+        DerivationTool.getAddressMetadata(tAddress).map {
+            $0.networkType == backend.networkType && (
+                $0.addressType == AddressType.p2pkh || $0.addressType == AddressType.p2sh
+            )
+        } ?? false
     }
-    
+
     public func isValidSaplingAddress(_ zAddress: String) -> Bool {
-        backend.isValidSaplingAddress(zAddress)
+        DerivationTool.getAddressMetadata(zAddress).map {
+            $0.networkType == backend.networkType && $0.addressType == AddressType.sapling
+        } ?? false
+    }
+
+    public func isValidTexAddress(_ texAddress: String) -> Bool {
+        DerivationTool.getAddressMetadata(texAddress).map {
+            $0.networkType == backend.networkType && $0.addressType == AddressType.tex
+        } ?? false
     }
 
     public func isValidSaplingExtendedSpendingKey(_ extsk: String) -> Bool {
@@ -155,6 +169,16 @@ extension UnifiedAddress {
     }
 }
 
+extension TexAddress {
+    /// This constructor is for internal use for Strings encodings that are assumed to be
+    /// already validated by another function. only for internal use. Unless you are
+    /// constructing an address from a primitive function of the FFI, you probably
+    /// shouldn't be using this.
+    init(validatedEncoding: String) {
+        self.encoding = validatedEncoding
+    }
+}
+
 extension UnifiedFullViewingKey {
     /// This constructor is for internal use for Strings encodings that are assumed to be
     /// already validated by another function. only for internal use. Unless you are

package/ios/ZCashLightClientKit/Tor/TorClient.swift

@@ -0,0 +1,57 @@
+//
+//  TorRuntime.swift
+//
+//
+//  Created by Jack Grigg on 04/06/2024.
+//
+
+import Foundation
+
+
+public class TorClient {
+    private let runtime: OpaquePointer
+    public var cachedFiatCurrencyResult: FiatCurrencyResult?
+
+    init(torDir: URL) async throws {
+        // Ensure that the directory exists.
+        let fileManager = FileManager()
+        if !fileManager.fileExists(atPath: torDir.path) {
+            do {
+                try fileManager.createDirectory(at: torDir, withIntermediateDirectories: true)
+            } catch {
+                throw ZcashError.blockRepositoryCreateBlocksCacheDirectory(torDir, error)
+            }
+        }
+
+        let rawDir = torDir.osPathStr()
+        let runtimePtr = zcashlc_create_tor_runtime(rawDir.0, rawDir.1)
+
+        guard let runtimePtr else {
+            throw ZcashError.rustTorClientInit(lastErrorMessage(fallback: "`TorClient` init failed with unknown error"))
+        }
+
+        runtime = runtimePtr
+    }
+
+    deinit {
+        zcashlc_free_tor_runtime(runtime)
+    }
+
+    public func getExchangeRateUSD() async throws -> FiatCurrencyResult {
+        let rate = zcashlc_get_exchange_rate_usd(runtime)
+
+        if rate.is_sign_negative {
+            throw ZcashError.rustTorClientGet(lastErrorMessage(fallback: "`TorClient.get` failed with unknown error"))
+        }
+
+        let newValue = FiatCurrencyResult(
+            date: Date(),
+            rate: NSDecimalNumber(mantissa: rate.mantissa, exponent: rate.exponent, isNegative: rate.is_sign_negative),
+            state: .success
+        )
+        
+        cachedFiatCurrencyResult = newValue
+        
+        return newValue
+    }
+}

package/ios/ZCashLightClientKit/Utils/LoggingProxy.swift

@@ -11,6 +11,7 @@ import Foundation
 Represents what's expected from a logging entity
 */
 public protocol Logger {
+    func maxLogLevel() -> OSLogger.LogLevel?
     func debug(_ message: String, file: StaticString, function: StaticString, line: Int)
     func info(_ message: String, file: StaticString, function: StaticString, line: Int)
     func event(_ message: String, file: StaticString, function: StaticString, line: Int)
@@ -44,6 +45,9 @@ extension Logger {
 A concrete logger implementation that logs nothing at all
  */
 struct NullLogger: Logger {
+    func maxLogLevel() -> OSLogger.LogLevel? {
+        nil
+    }
     func debug(_ message: String, file: StaticString, function: StaticString, line: Int) {}
     func info(_ message: String, file: StaticString, function: StaticString, line: Int) {}
     func event(_ message: String, file: StaticString, function: StaticString, line: Int) {}

package/ios/ZCashLightClientKit/Utils/OSLogger.swift

@@ -39,6 +39,10 @@ public class OSLogger: Logger {
         }
     }
 
+    public func maxLogLevel() -> LogLevel? {
+        self.level
+    }
+
     public func debug(
         _ message: String,
         file: StaticString = #file,