react-native-zcash 0.3.4 → 0.3.5

package/ios/ZCashLightClientKit/Extensions/Data+internal.swift

@@ -0,0 +1,35 @@
+//
+//  Data+internal.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 4/23/20.
+//
+
+import Foundation
+
+extension String {
+    func toTxIdString() -> String {
+        var id = ""
+        self.reversed().pairs
+            .map {
+                $0.reversed()
+            }
+            .forEach { reversed in
+                id.append(String(reversed))
+            }
+        return id
+    }
+}
+
+extension Collection {
+    var pairs: [SubSequence] {
+        var startIndex = self.startIndex
+        let count = self.count
+        let halving = count / 2 + count % 2
+        return (0..<halving).map { _ in
+            let endIndex = index(startIndex, offsetBy: 2, limitedBy: self.endIndex) ?? self.endIndex
+            defer { startIndex = endIndex }
+            return self[startIndex..<endIndex]
+        }
+    }
+}

package/ios/ZCashLightClientKit/Extensions/HexEncode.swift

@@ -0,0 +1,41 @@
+//
+//  File.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/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,357 @@
+//
+//  Initializer.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 13/09/2019.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+/**
+Wrapper for the Rust backend. This class basically represents all the Rust-wallet
+capabilities and the supporting data required to exercise those abilities.
+*/
+public enum InitializerError: Error {
+    case cacheDbInitFailed
+    case dataDbInitFailed
+    case accountInitFailed
+    case falseStart
+    case invalidViewingKey(key: String)
+}
+
+/**
+Represents a lightwallet instance endpoint to connect to
+*/
+public struct LightWalletEndpoint {
+    public var host: String
+    public var port: Int
+    public var secure: Bool
+    public var singleCallTimeoutInMillis: Int64
+    public var 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
+        - streamingCallTimeoutInMillis: timeout for streaming calls in Milliseconds
+    */
+    public init(
+        address: String,
+        port: Int,
+        secure: Bool = true,
+        singleCallTimeoutInMillis: Int64 = 10000,
+        streamingCallTimeoutInMillis: Int64 = 100000
+    ) {
+        self.host = address
+        self.port = port
+        self.secure = secure
+        self.singleCallTimeoutInMillis = singleCallTimeoutInMillis
+        self.streamingCallTimeoutInMillis = streamingCallTimeoutInMillis
+    }
+}
+
+/**
+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.
+*/
+public class Initializer {
+    private(set) var rustBackend: ZcashRustBackendWelding.Type
+    private(set) var alias: String
+    private(set) var endpoint: LightWalletEndpoint
+    
+    private var lowerBoundHeight: BlockHeight
+    private(set) var cacheDbURL: URL
+    private(set) var dataDbURL: URL
+    private(set) var pendingDbURL: URL
+    private(set) var spendParamsURL: URL
+    private(set) var outputParamsURL: URL
+    private(set) var lightWalletService: LightWalletService
+    private(set) var transactionRepository: TransactionRepository
+    private(set) var accountRepository: AccountRepository
+    private(set) var storage: CompactBlockStorage
+    private(set) var downloader: CompactBlockDownloader
+    private(set) var network: ZcashNetwork
+    private(set) public var viewingKeys: [UnifiedViewingKey]
+    private(set) public var walletBirthday: WalletBirthday
+
+    /**
+    Constructs the Initializer
+    - Parameters:
+        - cacheDbURL: location of the compact blocks cache db
+        - dataDbURL: Location of the data db
+        - pendingDbURL: location of the pending transactions database
+        - 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,
+        dataDbURL: URL,
+        pendingDbURL: URL,
+        endpoint: LightWalletEndpoint,
+        network: ZcashNetwork,
+        spendParamsURL: URL,
+        outputParamsURL: URL,
+        viewingKeys: [UnifiedViewingKey],
+        walletBirthday: BlockHeight,
+        alias: String = "",
+        loggerProxy: Logger? = nil
+    ) {
+        let lwdService = LightWalletGRPCService(endpoint: endpoint)
+        
+        self.init(
+            rustBackend: ZcashRustBackend.self,
+            lowerBoundHeight: walletBirthday,
+            network: network,
+            cacheDbURL: cacheDbURL,
+            dataDbURL: dataDbURL,
+            pendingDbURL: pendingDbURL,
+            endpoint: endpoint,
+            service: lwdService,
+            repository: TransactionRepositoryBuilder.build(dataDbURL: dataDbURL),
+            accountRepository: AccountRepositoryBuilder.build(
+                dataDbURL: dataDbURL,
+                readOnly: true,
+                caching: true
+            ),
+            storage: CompactBlockStorage(url: cacheDbURL, readonly: false),
+            spendParamsURL: spendParamsURL,
+            outputParamsURL: outputParamsURL,
+            viewingKeys: viewingKeys,
+            walletBirthday: walletBirthday,
+            alias: alias,
+            loggerProxy: loggerProxy
+        )
+    }
+    
+    /**
+    Internal for dependency injection purposes
+    */
+    init(
+        rustBackend: ZcashRustBackendWelding.Type,
+        lowerBoundHeight: BlockHeight,
+        network: ZcashNetwork,
+        cacheDbURL: URL,
+        dataDbURL: URL,
+        pendingDbURL: URL,
+        endpoint: LightWalletEndpoint,
+        service: LightWalletService,
+        repository: TransactionRepository,
+        accountRepository: AccountRepository,
+        storage: CompactBlockStorage,
+        spendParamsURL: URL,
+        outputParamsURL: URL,
+        viewingKeys: [UnifiedViewingKey],
+        walletBirthday: BlockHeight,
+        alias: String = "",
+        loggerProxy: Logger? = nil
+    ) {
+        logger = loggerProxy
+        self.rustBackend = rustBackend
+        self.lowerBoundHeight = lowerBoundHeight
+        self.cacheDbURL = cacheDbURL
+        self.dataDbURL = dataDbURL
+        self.pendingDbURL = pendingDbURL
+        self.endpoint = endpoint
+        self.spendParamsURL = spendParamsURL
+        self.outputParamsURL = outputParamsURL
+        self.alias = alias
+        self.lightWalletService = service
+        self.transactionRepository = repository
+        self.accountRepository = accountRepository
+        self.storage = storage
+        self.downloader = CompactBlockDownloader(service: service, storage: storage)
+        self.viewingKeys = viewingKeys
+        self.walletBirthday = WalletBirthday.birthday(with: walletBirthday, network: network)
+        self.network = network
+    }
+    
+    /**
+    Initialize the wallet with the given seed and return the related private keys for each
+    account specified or null if the wallet was previously initialized and block data exists on
+    disk. When this method returns null, that signals that the wallet will need to retrieve the
+    private keys from its own secure storage. In other words, the private keys are only given out
+    once for each set of database files. Subsequent calls to [initialize] will only load the Rust
+    library and return null.
+     
+    'compactBlockCache.db' and 'transactionData.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
+
+    - Parameters:
+        - viewingKeys: Extended Full Viewing Keys to initialize the DBs with
+    */
+    public func initialize() throws {
+        do {
+            try storage.createTable()
+        } catch {
+            throw InitializerError.cacheDbInitFailed
+        }
+        
+        do {
+            try rustBackend.initDataDb(dbData: dataDbURL, networkType: network.networkType)
+        } catch RustWeldingError.dataDbNotEmpty {
+            // this is fine
+        } catch {
+            throw InitializerError.dataDbInitFailed
+        }
+    
+        do {
+            try rustBackend.initBlocksTable(
+                dbData: dataDbURL,
+                height: Int32(walletBirthday.height),
+                hash: walletBirthday.hash,
+                time: walletBirthday.time,
+                saplingTree: walletBirthday.tree,
+                networkType: network.networkType
+            )
+        } catch RustWeldingError.dataDbNotEmpty {
+            // this is fine
+        } catch {
+            throw InitializerError.dataDbInitFailed
+        }
+        
+        let lastDownloaded = (try? downloader.storage.latestHeight()) ?? walletBirthday.height
+        // resume from last downloaded block
+        lowerBoundHeight = max(walletBirthday.height, lastDownloaded)
+ 
+        do {
+            guard try rustBackend.initAccountsTable(
+                dbData: dataDbURL,
+                uvks: viewingKeys,
+                networkType: network.networkType
+            ) else {
+                throw rustBackend.lastError() ?? InitializerError.accountInitFailed
+            }
+        } catch RustWeldingError.dataDbNotEmpty {
+            // this is fine
+        } catch {
+            throw rustBackend.lastError() ?? InitializerError.accountInitFailed
+        }
+        
+        let migrationManager = MigrationManager(
+            cacheDbConnection: SimpleConnectionProvider(path: cacheDbURL.path),
+            dataDbConnection: SimpleConnectionProvider(path: dataDbURL.path),
+            pendingDbConnection: SimpleConnectionProvider(path: pendingDbURL.path),
+            networkType: self.network.networkType
+        )
+        
+        try migrationManager.performMigration(uvks: viewingKeys)
+    }
+    
+    /**
+    get address from the given account index
+    - Parameter account:  the index of the account
+    */
+    public func getAddress(index account: Int = 0) -> String? {
+        try? accountRepository.findBy(account: account)?.address
+    }
+
+    /**
+    get (unverified) balance from the given account index
+    - Parameter account: the index of the account
+    */
+    public func getBalance(account index: Int = 0) -> Int64 {
+        rustBackend.getBalance(dbData: dataDbURL, account: Int32(index), networkType: network.networkType)
+    }
+    
+    /**
+    get verified balance from the given account index
+    - Parameter account: the index of the account
+    */
+    public func getVerifiedBalance(account index: Int = 0) -> Int64 {
+        rustBackend.getVerifiedBalance(dbData: dataDbURL, account: Int32(index), networkType: network.networkType)
+    }
+    
+    /**
+    checks if the provided address is a valid shielded zAddress
+    */
+    public func isValidShieldedAddress(_ address: String) -> Bool {
+        (try? rustBackend.isValidShieldedAddress(address, networkType: network.networkType)) ?? false
+    }
+
+    /**
+    checks if the provided address is a transparent zAddress
+    */
+    public func isValidTransparentAddress(_ address: String) -> Bool {
+        (try? rustBackend.isValidTransparentAddress(address, networkType: network.networkType)) ?? false
+    }
+    
+    func isSpendParameterPresent() -> Bool {
+        FileManager.default.isReadableFile(atPath: self.spendParamsURL.path)
+    }
+    
+    func isOutputParameterPresent() -> Bool {
+        FileManager.default.isReadableFile(atPath: self.outputParamsURL.path)
+    }
+    
+    func downloadParametersIfNeeded(result: @escaping (Result<Bool, Error>) -> Void) {
+        let spendParameterPresent = isSpendParameterPresent()
+        let outputParameterPresent = isOutputParameterPresent()
+        
+        if spendParameterPresent && outputParameterPresent {
+            result(.success(true))
+            return
+        }
+        
+        let outputURL = self.outputParamsURL
+        let spendURL = self.spendParamsURL
+        
+        if !outputParameterPresent {
+            SaplingParameterDownloader.downloadOutputParameter(outputURL) { outputResult in
+                switch outputResult {
+                case .failure(let error):
+                    result(.failure(error))
+                case .success:
+                    guard !spendParameterPresent else {
+                        result(.success(false))
+                        return
+                    }
+                    SaplingParameterDownloader.downloadSpendParameter(spendURL) { spendResult in
+                        switch spendResult {
+                        case .failure(let error):
+                            result(.failure(error))
+                        case .success:
+                            result(.success(false))
+                        }
+                    }
+                }
+            }
+        } else if !spendParameterPresent {
+            SaplingParameterDownloader.downloadSpendParameter(spendURL) { spendResult in
+                switch spendResult {
+                case .failure(let error):
+                    result(.failure(error))
+                case .success:
+                    result(.success(false))
+                }
+            }
+        }
+    }
+}
+
+enum CompactBlockProcessorBuilder {
+    // swiftlint:disable:next function_parameter_count
+    static func buildProcessor(
+        configuration: CompactBlockProcessor.Configuration,
+        service: LightWalletService,
+        storage: CompactBlockStorage,
+        transactionRepository: TransactionRepository,
+        accountRepository: AccountRepository,
+        backend: ZcashRustBackendWelding.Type
+    ) -> CompactBlockProcessor {
+        return CompactBlockProcessor(
+            service: service,
+            storage: storage,
+            backend: backend,
+            config: configuration,
+            repository: transactionRepository,
+            accountRepository: accountRepository
+        )
+    }
+}

package/ios/ZCashLightClientKit/Model/WalletTypes.swift

@@ -0,0 +1,108 @@
+//
+//  WalletTypes.swift
+//  Pods
+//
+//  Created by Francisco Gindre on 4/6/21.
+//
+
+/**
+Represents the wallet's birthday which can be thought of as a checkpoint at the earliest moment in history where
+transactions related to this wallet could exist. Ideally, this would correspond to the latest block height at the
+time the wallet key was created. Worst case, the height of Sapling activation could be used (280000).
+ 
+Knowing a wallet's birthday can significantly reduce the amount of data that it needs to download because none of
+the data before that height needs to be scanned for transactions. However, we do need the Sapling tree data in
+order to construct valid transactions from that point forward. This birthday contains that tree data, allowing us
+to avoid downloading all the compact blocks required in order to generate it.
+ 
+New wallets can ignore any blocks created before their birthday.
+ 
+- Parameters:
+    - height: the height at the time the wallet was born
+    -  hash: the block hash corresponding to the given height
+    -  time: the time the wallet was born, in seconds
+    -  tree: the sapling tree corresponding to the given height. This takes around 15 minutes of processing to
+generate from scratch because all blocks since activation need to be considered. So when it is calculated in
+advance it can save the user a lot of time.
+*/
+public struct WalletBirthday: Equatable {
+    public private(set) var height: BlockHeight = -1
+    public private(set) var hash: String = ""
+    public private(set) var time: UInt32 = 0
+    public private(set) var tree: String = ""
+}
+
+
+extension WalletBirthday: Decodable {
+  //  let height: BlockHeight
+  //  let hash: String
+  //  let time: UInt32
+  //  let tree: String
+  //
+  //  func walletBirthday() -> WalletBirthday {
+  //    WalletBirthday(
+  //      height: height,
+  //      hash: hash,
+  //      time: time,
+  //      tree: tree
+  //    )
+  //  }
+
+  public enum CodingKeys: String, CodingKey {
+    case height
+    case hash
+    case time
+    case tree
+  }
+
+  public init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    self.height = try Self.getHeight(from: container)
+    self.hash = try container.decode(String.self, forKey: .hash)
+    self.time = try container.decode(UInt32.self, forKey: .time)
+    self.tree = try container.decode(String.self, forKey: .tree)
+  }
+
+  static func getHeight(from container: KeyedDecodingContainer<CodingKeys>) throws -> Int {
+    guard
+      let heightString = try? container.decode(String.self, forKey: .height),
+      let height = Int(heightString)
+    else {
+      throw DecodingError.typeMismatch(
+        String.self,
+        DecodingError.Context(
+          codingPath: [CodingKeys.height],
+          debugDescription: "expected height to be encoded as a string",
+          underlyingError: nil
+        )
+      )
+    }
+    return height
+  }
+}
+
+
+/**
+Groups a Sapling Extended Full Viewing Key an a tranparent address extended public key.
+*/
+
+public typealias ExtendedFullViewingKey = String
+public typealias ExtendedPublicKey = String
+
+public protocol UnifiedViewingKey {
+    var extfvk: ExtendedFullViewingKey { get set }
+    var extpub: ExtendedPublicKey { get set }
+}
+
+public typealias TransparentAddress = String
+public typealias SaplingShieldedAddress = String
+
+public protocol UnifiedAddress {
+    var tAddress: TransparentAddress { get }
+    var zAddress: SaplingShieldedAddress { get }
+}
+
+public protocol WalletBalance {
+    var verified: Int64 { get set }
+    var total: Int64 { get set }
+}

package/ios/ZCashLightClientKit/Providers/ResourceProvider.swift

@@ -0,0 +1,47 @@
+//
+//  ResourceProvider.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 19/09/2019.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+public enum ResourceProviderError: Error {
+    case unavailableResource
+}
+public protocol ResourceProvider {
+    var dataDbURL: URL { get }
+    var cacheDbURL: URL { get }
+}
+/**
+Convenience provider for a data db and cache db resources.
+*/
+public struct DefaultResourceProvider: ResourceProvider {
+    var network: ZcashNetwork
+
+    public var dataDbURL: URL {
+        let constants = network.constants
+        do {
+            let url = try FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+            return url.appendingPathComponent(constants.defaultDataDbName)
+        } catch {
+            return URL(fileURLWithPath: "file://\(constants.defaultDataDbName)")
+        }
+    }
+    
+    public var cacheDbURL: URL {
+        let constants = network.constants
+        do {
+            let path = try FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+            return path.appendingPathComponent(constants.defaultCacheDbName)
+        } catch {
+            return URL(fileURLWithPath: "file://\(constants.defaultCacheDbName)")
+        }
+    }
+
+    init(network: ZcashNetwork) {
+        self.network = network
+    }
+}

package/ios/ZCashLightClientKit/Repository/BlockRepository.swift

@@ -0,0 +1,13 @@
+//
+//  BlockRepository.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/16/19.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+protocol BlockRepository {
+    func lastScannedBlockHeight() -> BlockHeight
+}