react-native-zcash 0.3.4 → 0.4.0

package/ios/ZCashLightClientKit/Extensions/HexEncode.swift

@@ -0,0 +1,41 @@
+//
+//  HexEncode.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 12/13/19.
+//
+
+import Foundation
+import CommonCrypto
+
+/**
+Thanks Stack Overflow (once again) https://stackoverflow.com/questions/39075043/how-to-convert-data-to-hex-string-in-swift
+*/
+struct HexEncodingOptions: OptionSet {
+    public static let upperCase = HexEncodingOptions(rawValue: 1 << 0)
+
+    public let rawValue: Int
+
+    public init(rawValue: Int) {
+        self.rawValue = rawValue
+    }
+}
+
+extension Data {
+    func hexEncodedString(options: HexEncodingOptions = []) -> String {
+        z_hexEncodedString(data: self, options: options)
+    }
+}
+
+func z_hexEncodedString(data: Data, options: HexEncodingOptions = []) -> String {
+    let hexDigits = Array((options.contains(.upperCase) ? "0123456789ABCDEF" : "0123456789abcdef").utf16)
+    var chars: [unichar] = []
+
+    chars.reserveCapacity(2 * data.count)
+    for byte in data {
+        chars.append(hexDigits[Int(byte / 16)])
+        chars.append(hexDigits[Int(byte % 16)])
+    }
+
+    return String(utf16CodeUnits: chars, count: chars.count)
+}

package/ios/ZCashLightClientKit/Extensions/NumberFormatter+Zcash.swift

@@ -0,0 +1,19 @@
+//
+//  NumberFormatter+Zcash.swift
+//  
+//  Created by Lukáš Korba on 02.06.2022.
+//  modified by Francisco Gindre on 6/17/22.
+//
+
+import Foundation
+
+public extension NumberFormatter {
+    static let zcashNumberFormatter: NumberFormatter = {
+        var formatter = NumberFormatter()
+        formatter.maximumFractionDigits = 8
+        formatter.maximumIntegerDigits = 8
+        formatter.numberStyle = .decimal
+        formatter.usesGroupingSeparator = true
+        return formatter
+    }()
+}

package/ios/ZCashLightClientKit/Extensions/URL+UpdateWithAlias.swift

@@ -0,0 +1,36 @@
+//
+//  URL+UpdateWithAlias.swift
+//  
+//
+//  Created by Michal Fousek on 23.03.2023.
+//
+
+import Foundation
+
+extension URL {
+    /// Try to update URLs with `alias`.
+    ///
+    /// If the `default` alias is used then the URL isn't changed at all.
+    /// If the `custom("anotherInstance")` is used then last path component or the URL is updated like this:
+    /// - /some/path/to.file -> /some/path/c_anotherInstance_to.file
+    /// - /some/path/to/directory -> /some/path/to/c_anotherInstance_directory
+    ///
+    /// If the URLs can't be parsed then `nil` is returned.
+    func updateLastPathComponent(with alias: ZcashSynchronizerAlias) -> URL? {
+        let lastPathComponent = self.lastPathComponent
+        guard !lastPathComponent.isEmpty else {
+            return nil
+        }
+
+        switch alias {
+        case .`default`:
+            // When using default alias everything should work as before aliases to be backwards compatible.
+            return self
+
+        case .custom:
+            let newLastPathComponent = "\(alias.description)_\(lastPathComponent)"
+            return self.deletingLastPathComponent()
+                .appendingPathComponent(newLastPathComponent)
+        }
+    }
+}

package/ios/ZCashLightClientKit/Extensions/Undescribable.swift

@@ -0,0 +1,22 @@
+//
+//  undescribable.swift
+//  
+//
+//  Created by Francisco Gindre on 8/30/22.
+//
+
+public protocol Undescribable: CustomStringConvertible, CustomDebugStringConvertible, CustomLeafReflectable {}
+
+extension Undescribable {
+    public var description: String {
+        return "--redacted--"
+    }
+    
+    public var debugDescription: String {
+        return "--redacted--"
+    }
+    
+    public var customMirror: Mirror {
+        return Mirror(reflecting: "--redacted--")
+    }
+}

package/ios/ZCashLightClientKit/Extensions/Zatoshi+SQLite.swift

@@ -0,0 +1,20 @@
+//
+//  Zatoshi+SQLite.swift
+//  
+//
+//  Created by Francisco Gindre on 6/20/22.
+//
+
+import SQLite
+
+extension Zatoshi: Value {
+    public static let declaredDatatype = Int64.declaredDatatype
+
+    public static func fromDatatypeValue(_ datatypeValue: Int64) -> Zatoshi {
+        Zatoshi(datatypeValue)
+    }
+
+    public var datatypeValue: Int64 {
+        self.amount
+    }
+}

package/ios/ZCashLightClientKit/Extensions/ZcashRust+Utils.swift

@@ -0,0 +1,26 @@
+//
+//  ZcashRust+Utils.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 12/09/2019.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+/**
+Attempts to show the data as a Zcash Transaction Memo
+*/
+public extension Data {
+    func asZcashTransactionMemo() -> String? {
+        String(data: self, encoding: .utf8)
+    }
+}
+
+/**
+Attempts to convert this string to a Zcash Transaction Memo data
+*/
+public extension String {
+    func encodeAsZcashTransactionMemo() -> Data? {
+        return self.data(using: .utf8)
+    }
+}

package/ios/ZCashLightClientKit/Extensions/ZcashSDK+extensions.swift

@@ -0,0 +1,34 @@
+//
+//  ZcashSDK+extensions.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 12/8/20.
+//
+
+import Foundation
+
+public typealias ConsensusBranchID = Int32
+
+public extension ConsensusBranchID {
+    func toString() -> String {
+        String(format: "%02x", self)
+    }
+    
+    static func fromString(_ str: String) -> ConsensusBranchID? {
+        guard let bitpattern = UInt32(str, radix: 16) else { return nil }
+        return Int32(bitPattern: bitpattern)
+    }
+}
+
+extension NetworkType {
+    init?(_ string: String) {
+        switch string {
+        case "main":
+            self = .mainnet
+        case "test":
+            self = .testnet
+        default:
+            return nil
+        }
+    }
+}

package/ios/ZCashLightClientKit/Initializer.swift

@@ -0,0 +1,433 @@
+//
+//  Initializer.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 13/09/2019.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+/**
+Represents a lightwallet instance endpoint to connect to
+*/
+public struct LightWalletEndpoint {
+    public let host: String
+    public let port: Int
+    public let secure: Bool
+    public let singleCallTimeoutInMillis: Int64
+    public let streamingCallTimeoutInMillis: Int64
+    
+    /**
+    initializes a LightWalletEndpoint
+    - Parameters:
+        - address: a String containing the host address
+        - port: string with the port of the host address
+        - secure: true if connecting through TLS. Default value is true
+        - singleCallTimeoutInMillis: timeout for single calls in Milliseconds. Default 30 seconds
+        - streamingCallTimeoutInMillis: timeout for streaming calls in Milliseconds. Default 100 seconds
+    */
+    public init(
+        address: String,
+        port: Int,
+        secure: Bool = true,
+        singleCallTimeoutInMillis: Int64 = 30000,
+        streamingCallTimeoutInMillis: Int64 = 100000
+    ) {
+        self.host = address
+        self.port = port
+        self.secure = secure
+        self.singleCallTimeoutInMillis = singleCallTimeoutInMillis
+        self.streamingCallTimeoutInMillis = streamingCallTimeoutInMillis
+    }
+}
+
+/// This contains URLs from which can the SDK fetch files that contain sapling parameters.
+/// Use `SaplingParamsSourceURL.default` when initilizing the SDK.
+public struct SaplingParamsSourceURL {
+    public let spendParamFileURL: URL
+    public let outputParamFileURL: URL
+
+    public static var `default`: SaplingParamsSourceURL {
+        return SaplingParamsSourceURL(spendParamFileURL: ZcashSDK.spendParamFileURL, outputParamFileURL: ZcashSDK.outputParamFileURL)
+    }
+}
+
+/// This identifies different instances of the synchronizer. It is usefull when the client app wants to support multiple wallets (with different
+/// seeds) in one app. If the client app support only one wallet then it doesn't have to care about alias atall.
+///
+/// When custom alias is used to create instance of the synchronizer then paths to all resources (databases, storages...) are updated accordingly to
+/// be sure that each instance is using unique paths to resources.
+///
+/// Custom alias identifiers shouldn't contain any confidential information because it may be logged. It also should have a reasonable length and
+/// form. It will be part of the paths to the files (databases, storage...)
+///
+/// IMPORTANT: Always use `default` alias for one of the instances of the synchronizer.
+public enum ZcashSynchronizerAlias: Hashable {
+    case `default`
+    case custom(String)
+}
+
+extension ZcashSynchronizerAlias: CustomStringConvertible {
+    public var description: String {
+        switch self {
+        case .`default`:
+            return "default"
+        case let .custom(alias):
+            return "c_\(alias)"
+        }
+    }
+}
+
+/**
+Wrapper for all the Rust backend functionality that does not involve processing blocks. This
+class initializes the Rust backend and the supporting data required to exercise those abilities.
+The [cash.z.wallet.sdk.block.CompactBlockProcessor] handles all the remaining Rust backend
+functionality, related to processing blocks.
+*/
+// swiftlint:disable:next type_body_length
+public class Initializer {
+    struct URLs {
+        let fsBlockDbRoot: URL
+        let dataDbURL: URL
+        let spendParamsURL: URL
+        let outputParamsURL: URL
+    }
+
+    public enum InitializationResult {
+        case success
+        case seedRequired
+    }
+    
+    public enum LoggingPolicy {
+        case `default`(OSLogger.LogLevel)
+        case custom(Logger)
+        case noLogging
+    }
+
+    // This is used to uniquely identify instance of the SDKSynchronizer. It's used when checking if the Alias is already used or not.
+    let id = UUID()
+
+    let container: DIContainer
+    let alias: ZcashSynchronizerAlias
+    let endpoint: LightWalletEndpoint
+    let fsBlockDbRoot: URL
+    let dataDbURL: URL
+    let spendParamsURL: URL
+    let outputParamsURL: URL
+    let saplingParamsSourceURL: SaplingParamsSourceURL
+    let lightWalletService: LightWalletService
+    let transactionRepository: TransactionRepository
+    let accountRepository: AccountRepository
+    let storage: CompactBlockRepository
+    let blockDownloaderService: BlockDownloaderService
+    let network: ZcashNetwork
+    let logger: Logger
+    let rustBackend: ZcashRustBackendWelding
+
+    /// The effective birthday of the wallet based on the height provided when initializing and the checkpoints available on this SDK.
+    ///
+    /// This contains valid value only after `initialize` function is called.
+    public private(set) var walletBirthday: BlockHeight
+
+    /// The purpose of this to migrate from cacheDb to fsBlockDb
+    private let cacheDbURL: URL?
+
+    /// Error that can be created when updating URLs according to alias. If this error is created then it is thrown from `SDKSynchronizer.prepare()`
+    /// or `SDKSynchronizer.wipe()`.
+    var urlsParsingError: ZcashError?
+
+    /// Constructs the Initializer and migrates an old cacheDb to the new file system block cache if a `cacheDbURL` is provided.
+    /// - Parameters:
+    ///  - cacheDbURL: previous location of the cacheDb. If you don't know what a cacheDb is and you are adopting this SDK for the first time then
+    ///                just pass `nil` here.
+    ///  - fsBlockDbRoot: location of the compact blocks cache
+    ///  - dataDbURL: Location of the data db
+    ///  - endpoint: the endpoint representing the lightwalletd instance you want to point to
+    ///  - spendParamsURL: location of the spend parameters
+    ///  - outputParamsURL: location of the output parameters
+    convenience public init(
+        cacheDbURL: URL?,
+        fsBlockDbRoot: URL,
+        dataDbURL: URL,
+        endpoint: LightWalletEndpoint,
+        network: ZcashNetwork,
+        spendParamsURL: URL,
+        outputParamsURL: URL,
+        saplingParamsSourceURL: SaplingParamsSourceURL,
+        alias: ZcashSynchronizerAlias = .default,
+        loggingPolicy: LoggingPolicy = .default(.debug)
+    ) {
+        let container = DIContainer()
+        
+        // It's not possible to fail from constructor. Technically it's possible but it can be pain for the client apps to handle errors thrown
+        // from constructor. So `parsingError` is just stored in initializer and `SDKSynchronizer.prepare()` throw this error if it exists.
+        let (updatedURLs, parsingError) = Self.setup(
+            container: container,
+            cacheDbURL: cacheDbURL,
+            fsBlockDbRoot: fsBlockDbRoot,
+            dataDbURL: dataDbURL,
+            endpoint: endpoint,
+            network: network,
+            spendParamsURL: spendParamsURL,
+            outputParamsURL: outputParamsURL,
+            saplingParamsSourceURL: saplingParamsSourceURL,
+            alias: alias,
+            loggingPolicy: loggingPolicy
+        )
+        
+        self.init(
+            container: container,
+            cacheDbURL: cacheDbURL,
+            urls: updatedURLs,
+            endpoint: endpoint,
+            network: network,
+            saplingParamsSourceURL: saplingParamsSourceURL,
+            alias: alias,
+            urlsParsingError: parsingError,
+            loggingPolicy: loggingPolicy
+        )
+    }
+
+    /// Internal for dependency injection purposes.
+    convenience init(
+        container: DIContainer,
+        cacheDbURL: URL?,
+        fsBlockDbRoot: URL,
+        dataDbURL: URL,
+        endpoint: LightWalletEndpoint,
+        network: ZcashNetwork,
+        spendParamsURL: URL,
+        outputParamsURL: URL,
+        saplingParamsSourceURL: SaplingParamsSourceURL,
+        alias: ZcashSynchronizerAlias = .default,
+        loggingPolicy: LoggingPolicy = .default(.debug)
+    ) {
+        // It's not possible to fail from constructor. Technically it's possible but it can be pain for the client apps to handle errors thrown
+        // from constructor. So `parsingError` is just stored in initializer and `SDKSynchronizer.prepare()` throw this error if it exists.
+        let (updatedURLs, parsingError) = Self.setup(
+            container: container,
+            cacheDbURL: cacheDbURL,
+            fsBlockDbRoot: fsBlockDbRoot,
+            dataDbURL: dataDbURL,
+            endpoint: endpoint,
+            network: network,
+            spendParamsURL: spendParamsURL,
+            outputParamsURL: outputParamsURL,
+            saplingParamsSourceURL: saplingParamsSourceURL,
+            alias: alias,
+            loggingPolicy: loggingPolicy
+        )
+
+        self.init(
+            container: container,
+            cacheDbURL: cacheDbURL,
+            urls: updatedURLs,
+            endpoint: endpoint,
+            network: network,
+            saplingParamsSourceURL: saplingParamsSourceURL,
+            alias: alias,
+            urlsParsingError: parsingError,
+            loggingPolicy: loggingPolicy
+        )
+    }
+    
+    private init(
+        container: DIContainer,
+        cacheDbURL: URL?,
+        urls: URLs,
+        endpoint: LightWalletEndpoint,
+        network: ZcashNetwork,
+        saplingParamsSourceURL: SaplingParamsSourceURL,
+        alias: ZcashSynchronizerAlias,
+        urlsParsingError: ZcashError?,
+        loggingPolicy: LoggingPolicy = .default(.debug)
+    ) {
+        self.container = container
+        self.cacheDbURL = cacheDbURL
+        self.rustBackend = container.resolve(ZcashRustBackendWelding.self)
+        self.fsBlockDbRoot = urls.fsBlockDbRoot
+        self.dataDbURL = urls.dataDbURL
+        self.endpoint = endpoint
+        self.spendParamsURL = urls.spendParamsURL
+        self.outputParamsURL = urls.outputParamsURL
+        self.saplingParamsSourceURL = saplingParamsSourceURL
+        self.alias = alias
+        self.lightWalletService = container.resolve(LightWalletService.self)
+        self.transactionRepository = container.resolve(TransactionRepository.self)
+        self.accountRepository = AccountRepositoryBuilder.build(
+            dataDbURL: urls.dataDbURL,
+            readOnly: true,
+            caching: true,
+            logger: container.resolve(Logger.self)
+        )
+        self.storage = container.resolve(CompactBlockRepository.self)
+        self.blockDownloaderService = container.resolve(BlockDownloaderService.self)
+        self.network = network
+        self.walletBirthday = Checkpoint.birthday(with: 0, network: network).height
+        self.urlsParsingError = urlsParsingError
+        self.logger = container.resolve(Logger.self)
+    }
+    
+    private static func makeLightWalletServiceFactory(endpoint: LightWalletEndpoint) -> LightWalletServiceFactory {
+        return LightWalletServiceFactory(endpoint: endpoint)
+    }
+    
+    // swiftlint:disable:next function_parameter_count
+    private static func setup(
+        container: DIContainer,
+        cacheDbURL: URL?,
+        fsBlockDbRoot: URL,
+        dataDbURL: URL,
+        endpoint: LightWalletEndpoint,
+        network: ZcashNetwork,
+        spendParamsURL: URL,
+        outputParamsURL: URL,
+        saplingParamsSourceURL: SaplingParamsSourceURL,
+        alias: ZcashSynchronizerAlias,
+        loggingPolicy: LoggingPolicy = .default(.debug)
+    ) -> (URLs, ZcashError?) {
+        let urls = URLs(
+            fsBlockDbRoot: fsBlockDbRoot,
+            dataDbURL: dataDbURL,
+            spendParamsURL: spendParamsURL,
+            outputParamsURL: outputParamsURL
+        )
+        
+        // It's not possible to fail from constructor. Technically it's possible but it can be pain for the client apps to handle errors thrown
+        // from constructor. So `parsingError` is just stored in initializer and `SDKSynchronizer.prepare()` throw this error if it exists.
+        let (updatedURLs, parsingError) = Self.tryToUpdateURLs(with: alias, urls: urls)
+        
+        Dependencies.setup(
+            in: container,
+            urls: updatedURLs,
+            alias: alias,
+            networkType: network.networkType,
+            endpoint: endpoint,
+            loggingPolicy: loggingPolicy
+        )
+        
+        return (updatedURLs, parsingError)
+    }
+
+    /// Try to update URLs with `alias`.
+    ///
+    /// If the `default` alias is used then the URLs are changed at all.
+    /// If the `custom("anotherInstance")` is used then last path component or the URL is updated like this:
+    /// - /some/path/to.file -> /some/path/c_anotherInstance_to.file
+    /// - /some/path/to/directory -> /some/path/to/c_anotherInstance_directory
+    ///
+    /// If any of the URLs can't be parsed then returned error isn't nil.
+    static func tryToUpdateURLs(
+        with alias: ZcashSynchronizerAlias,
+        urls: URLs
+    ) -> (URLs, ZcashError?) {
+        let updatedURLsResult = Self.updateURLs(with: alias, urls: urls)
+
+        let parsingError: ZcashError?
+        let updatedURLs: URLs
+        switch updatedURLsResult {
+        case let .success(updated):
+            parsingError = nil
+            updatedURLs = updated
+        case let .failure(error):
+            parsingError = error
+            // When failure happens just use original URLs because something must be used. But this shouldn't be a problem because
+            // `SDKSynchronizer.prepare()` handles this error. And the SDK won't work if it isn't switched from `unprepared` state.
+            updatedURLs = urls
+        }
+
+        return (updatedURLs, parsingError)
+    }
+
+    private static func updateURLs(
+        with alias: ZcashSynchronizerAlias,
+        urls: URLs
+    ) -> Result<URLs, ZcashError> {
+        guard let updatedFsBlockDbRoot = urls.fsBlockDbRoot.updateLastPathComponent(with: alias) else {
+            return .failure(.initializerCantUpdateURLWithAlias(urls.fsBlockDbRoot))
+        }
+
+        guard let updatedDataDbURL = urls.dataDbURL.updateLastPathComponent(with: alias) else {
+            return .failure(.initializerCantUpdateURLWithAlias(urls.dataDbURL))
+        }
+
+        guard let updatedSpendParamsURL = urls.spendParamsURL.updateLastPathComponent(with: alias) else {
+            return .failure(.initializerCantUpdateURLWithAlias(urls.spendParamsURL))
+        }
+
+        guard let updateOutputParamsURL = urls.outputParamsURL.updateLastPathComponent(with: alias) else {
+            return .failure(.initializerCantUpdateURLWithAlias(urls.outputParamsURL))
+        }
+
+        return .success(
+            URLs(
+                fsBlockDbRoot: updatedFsBlockDbRoot,
+                dataDbURL: updatedDataDbURL,
+                spendParamsURL: updatedSpendParamsURL,
+                outputParamsURL: updateOutputParamsURL
+            )
+        )
+    }
+
+    /// 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
+    /// be the case that this method is invoked by a wallet that does not contain the seed phrase
+    /// and is view-only, or by a wallet that does have the seed but the process does not have the
+    /// consent of the OS to fetch the keys from the secure storage, like on background tasks.
+    ///
+    /// 'cache.db' and 'data.db' files are created by this function (if they
+    /// do not already exist). These files can be given a prefix for scenarios where multiple wallets
+    ///
+    /// - Parameter seed: ZIP-32 Seed bytes for the wallet that will be initialized
+    /// - Throws: `InitializerError.dataDbInitFailed` if the creation of the dataDb fails
+    /// `InitializerError.accountInitFailed` if the account table can't be initialized. 
+    func initialize(with seed: [UInt8]?, viewingKeys: [UnifiedFullViewingKey], walletBirthday: BlockHeight) async throws -> InitializationResult {
+        try await storage.create()
+
+        if case .seedRequired = try await rustBackend.initDataDb(seed: seed) {
+            return .seedRequired
+        }
+
+        let checkpoint = Checkpoint.birthday(with: walletBirthday, network: network)
+        do {
+            try await rustBackend.initBlocksTable(
+                height: Int32(checkpoint.height),
+                hash: checkpoint.hash,
+                time: checkpoint.time,
+                saplingTree: checkpoint.saplingTree
+            )
+        } catch ZcashError.rustInitBlocksTableDataDbNotEmpty {
+            // this is fine
+        } catch {
+            throw error
+        }
+
+        self.walletBirthday = checkpoint.height
+ 
+        do {
+            try await rustBackend.initAccountsTable(ufvks: viewingKeys)
+        } catch ZcashError.rustInitAccountsTableDataDbNotEmpty {
+            // this is fine
+        } catch {
+            throw error
+        }
+
+        return .success
+    }
+    
+    /**
+    checks if the provided address is a valid sapling address
+    */
+    public func isValidSaplingAddress(_ address: String) -> Bool {
+        DerivationTool(networkType: network.networkType).isValidSaplingAddress(address)
+    }
+
+    /**
+    checks if the provided address is a transparent zAddress
+    */
+    public func isValidTransparentAddress(_ address: String) -> Bool {
+        DerivationTool(networkType: network.networkType).isValidTransparentAddress(address)
+    }
+}