react-native-zcash 0.3.4 → 0.3.5

package/ios/ZCashLightClientKit/Transaction/TransactionEncoder.swift

@@ -0,0 +1,116 @@
+//
+//  TransactionEncoder.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/20/19.
+//
+
+import Foundation
+
+typealias TransactionEncoderResultBlock = (_ result: Result<EncodedTransaction, Error>) -> Void
+
+public enum TransactionEncoderError: Error {
+    case notFound(transactionId: Int)
+    case notEncoded(transactionId: Int)
+    case missingParams
+    case spendingKeyWrongNetwork
+    case couldNotExpand(txId: Data)
+}
+
+protocol TransactionEncoder {
+    /**
+    Creates a transaction, throwing an exception whenever things are missing. When the provided wallet implementation
+    doesn't throw an exception, we wrap the issue into a descriptive exception ourselves (rather than using
+    double-bangs for things).
+    Blocking
+     
+    - Parameters:
+    - Parameter spendingKey: a string containing the spending key
+    - Parameter zatoshi: the amount to send in zatoshis
+    - Parameter to: string containing the recipient address
+    - Parameter memo: string containing the memo (optional)
+    - Parameter accountIndex: index of the account that will be used to send the funds
+     
+    - Throws: a TransactionEncoderError
+    */
+    func createTransaction(
+        spendingKey: String,
+        zatoshi: Int,
+        to address: String,
+        memo: String?,
+        from accountIndex: Int
+    ) throws -> EncodedTransaction
+    
+    /**
+    Creates a transaction, throwing an exception whenever things are missing. When the provided wallet implementation
+    doesn't throw an exception, we wrap the issue into a descriptive exception ourselves (rather than using
+    double-bangs for things).
+    Non-blocking
+     
+    - Parameters:
+    - Parameter spendingKey: a string containing the spending key
+    - Parameter zatoshi: the amount to send in zatoshis
+    - Parameter to: string containing the recipient address
+    - Parameter memo: string containing the memo (optional)
+    - Parameter accountIndex: index of the account that will be used to send the funds
+    - Parameter result: a non escaping closure that receives a Result containing either an EncodedTransaction or a TransactionEncoderError
+    */
+    // swiftlint:disable:next function_parameter_count
+    func createTransaction(
+        spendingKey: String,
+        zatoshi: Int,
+        to address: String,
+        memo: String?,
+        from accountIndex: Int,
+        result: @escaping TransactionEncoderResultBlock
+    )
+    
+    /**
+    Creates a transaction that will attempt to shield transparent funds that are present on the cacheDB .throwing an exception whenever things are missing. When the provided wallet implementation doesn't throw an exception, we wrap the issue into a descriptive exception ourselves (rather than using double-bangs for things).
+    Blocking
+     
+    - Parameters:
+    - Parameter spendingKey: a string containing the spending key
+    - Parameter tSecretKey: transparent secret key to spend the UTXOs
+    - Parameter memo: string containing the memo (optional)
+    - Parameter accountIndex: index of the account that will be used to send the funds
+     
+    - Throws: a TransactionEncoderError
+    */
+    func createShieldingTransaction(
+        spendingKey: String,
+        tSecretKey: String,
+        memo: String?,
+        from accountIndex: Int
+    ) throws -> EncodedTransaction
+    
+    /**
+    Creates a transaction that will attempt to shield transparent funds that are present on the cacheDB .throwing an exception whenever things are missing. When the provided wallet implementation doesn't throw an exception, we wrap the issue into a descriptive exception ourselves (rather than using double-bangs for things).
+     
+    Non-Blocking
+     
+    - Parameters:
+        - Parameter spendingKey: a string containing the spending key
+        - Parameter tSecretKey: transparent secret key to spend the UTXOs
+        - Parameter memo: string containing the memo (optional)
+        - Parameter accountIndex: index of the account that will be used to send the funds
+     
+    - Returns: a TransactionEncoderResultBlock
+    */
+    
+    func createShieldingTransaction(
+        spendingKey: String,
+        tSecretKey: String,
+        memo: String?,
+        from accountIndex: Int,
+        result: @escaping TransactionEncoderResultBlock
+    )
+    
+    /**
+    Fetch the Transaction Entity from the encoded representation
+    - Parameter encodedTransaction: The encoded transaction to expand
+    - Returns: a TransactionEntity based on the given Encoded Transaction
+    - Throws: a TransactionEncoderError
+    */
+    func expandEncodedTransaction(_ encodedTransaction: EncodedTransaction) throws -> TransactionEntity
+}

package/ios/ZCashLightClientKit/Transaction/TransactionManager.swift

@@ -0,0 +1,42 @@
+//
+//  TransactionManager.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/26/19.
+//
+
+import Foundation
+
+/**
+Manage outbound transactions with the main purpose of reporting which ones are still pending,
+particularly after failed attempts or dropped connectivity. The intent is to help see outbound
+transactions through to completion.
+*/
+
+protocol OutboundTransactionManager {
+    func initSpend(zatoshi: Int, toAddress: String, memo: String?, from accountIndex: Int) throws -> PendingTransactionEntity
+
+    func encodeShieldingTransaction(spendingKey: String, tsk: String, pendingTransaction: PendingTransactionEntity, result: @escaping (Result<PendingTransactionEntity, Error>) -> Void)
+    
+    func encode(spendingKey: String, pendingTransaction: PendingTransactionEntity, result: @escaping (Result<PendingTransactionEntity, Error>) -> Void)
+    
+    func submit(pendingTransaction: PendingTransactionEntity, result: @escaping (Result<PendingTransactionEntity, Error>) -> Void)
+    
+    func applyMinedHeight(pendingTransaction: PendingTransactionEntity, minedHeight: BlockHeight) throws -> PendingTransactionEntity
+    
+    func monitorChanges(byId: Int, observer: Any) // check this out. code smell
+    
+    /**
+    Attempts to Cancel a transaction. Returns true if successful
+    */
+    func cancel(pendingTransaction: PendingTransactionEntity) -> Bool
+    
+    func allPendingTransactions() throws -> [PendingTransactionEntity]?
+    
+    func handleReorg(at blockHeight: BlockHeight) throws
+    
+    /**
+    Deletes a pending transaction from the database
+    */
+    func delete(pendingTransaction: PendingTransactionEntity) throws
+}

package/ios/ZCashLightClientKit/Transaction/WalletTransactionEncoder.swift

@@ -0,0 +1,216 @@
+//
+//  WalletTransactionEncoder.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/20/19.
+//
+
+import Foundation
+
+class WalletTransactionEncoder: TransactionEncoder {
+    var rustBackend: ZcashRustBackendWelding.Type
+    var repository: TransactionRepository
+    var queue: DispatchQueue
+
+    private var outputParamsURL: URL
+    private var spendParamsURL: URL
+    private var dataDbURL: URL
+    private var cacheDbURL: URL
+    private var networkType: NetworkType
+    
+    init(
+        rust: ZcashRustBackendWelding.Type,
+        dataDb: URL,
+        cacheDb: URL,
+        repository: TransactionRepository,
+        outputParams: URL,
+        spendParams: URL,
+        networkType: NetworkType
+    ) {
+        self.rustBackend = rust
+        self.dataDbURL = dataDb
+        self.cacheDbURL = cacheDb
+        self.repository = repository
+        self.outputParamsURL = outputParams
+        self.spendParamsURL = spendParams
+        self.networkType = networkType
+        self.queue = DispatchQueue(label: "wallet.transaction.encoder.serial.queue")
+    }
+    
+    convenience init(initializer: Initializer) {
+        self.init(
+            rust: initializer.rustBackend,
+            dataDb: initializer.dataDbURL,
+            cacheDb: initializer.cacheDbURL,
+            repository: initializer.transactionRepository,
+            outputParams: initializer.outputParamsURL,
+            spendParams: initializer.spendParamsURL,
+            networkType: initializer.network.networkType
+        )
+    }
+    
+    func createTransaction(
+        spendingKey: String,
+        zatoshi: Int,
+        to address: String,
+        memo: String?,
+        from accountIndex: Int
+    ) throws -> EncodedTransaction {
+        let txId = try createSpend(
+            spendingKey: spendingKey,
+            zatoshi: zatoshi,
+            to: address,
+            memo: memo,
+            from: accountIndex
+        )
+        
+        do {
+            let transactionEntity = try repository.findBy(id: txId)
+            guard let transaction = transactionEntity else {
+                throw TransactionEncoderError.notFound(transactionId: txId)
+            }
+
+            LoggerProxy.debug("sentTransaction id: \(txId)")
+
+            return EncodedTransaction(transactionId: transaction.transactionId, raw: transaction.raw)
+        } catch {
+            throw TransactionEncoderError.notFound(transactionId: txId)
+        }
+    }
+
+    // swiftlint:disable:next function_parameter_count
+    func createTransaction(
+        spendingKey: String,
+        zatoshi: Int,
+        to address: String,
+        memo: String?,
+        from accountIndex: Int,
+        result: @escaping TransactionEncoderResultBlock
+    ) {
+        queue.async { [weak self] in
+            guard let self = self else { return }
+            do {
+                result(
+                    .success(
+                        try self.createTransaction(
+                            spendingKey: spendingKey,
+                            zatoshi: zatoshi,
+                            to: address,
+                            memo: memo,
+                            from: accountIndex
+                        )
+                    )
+                )
+            } catch {
+                result(.failure(error))
+            }
+        }
+    }
+    
+    func createSpend(spendingKey: String, zatoshi: Int, to address: String, memo: String?, from accountIndex: Int) throws -> Int {
+        guard ensureParams(spend: self.spendParamsURL, output: self.spendParamsURL) else {
+            throw TransactionEncoderError.missingParams
+        }
+                
+        let txId = rustBackend.createToAddress(
+            dbData: self.dataDbURL,
+            account: Int32(accountIndex),
+            extsk: spendingKey,
+            to: address,
+            value: Int64(zatoshi),
+            memo: memo,
+            spendParamsPath: self.spendParamsURL.path,
+            outputParamsPath: self.outputParamsURL.path,
+            networkType: networkType
+        )
+        
+        guard txId > 0 else {
+            throw rustBackend.lastError() ?? RustWeldingError.genericError(message: "create spend failed")
+        }
+        
+        return Int(txId)
+    }
+    
+    func createShieldingTransaction(
+        spendingKey: String,
+        tSecretKey: String,
+        memo: String?,
+        from accountIndex: Int
+    ) throws -> EncodedTransaction {
+        let txId = try createShieldingSpend(
+            spendingKey: spendingKey,
+            tsk: tSecretKey,
+            memo: memo,
+            accountIndex: accountIndex
+        )
+        
+        do {
+            let transactionEntity = try repository.findBy(id: txId)
+            
+            guard let transaction = transactionEntity else {
+                throw TransactionEncoderError.notFound(transactionId: txId)
+            }
+            
+            LoggerProxy.debug("sentTransaction id: \(txId)")
+            return EncodedTransaction(transactionId: transaction.transactionId, raw: transaction.raw)
+        } catch {
+            throw TransactionEncoderError.notFound(transactionId: txId)
+        }
+    }
+    
+    func createShieldingTransaction(
+        spendingKey: String,
+        tSecretKey: String,
+        memo: String?,
+        from accountIndex: Int,
+        result: @escaping TransactionEncoderResultBlock
+    ) {
+        queue.async {
+            result(.failure(RustWeldingError.genericError(message: "not implemented")))
+        }
+    }
+    
+    func createShieldingSpend(spendingKey: String, tsk: String, memo: String?, accountIndex: Int) throws -> Int {
+        guard ensureParams(spend: self.spendParamsURL, output: self.spendParamsURL) else {
+            throw TransactionEncoderError.missingParams
+        }
+        
+        let txId = rustBackend.shieldFunds(
+            dbCache: self.cacheDbURL,
+            dbData: self.dataDbURL,
+            account: Int32(accountIndex),
+            tsk: tsk,
+            extsk: spendingKey,
+            memo: memo,
+            spendParamsPath: self.spendParamsURL.path,
+            outputParamsPath: self.outputParamsURL.path,
+            networkType: networkType
+        )
+        
+        guard txId > 0 else {
+            throw rustBackend.lastError() ?? RustWeldingError.genericError(message: "create spend failed")
+        }
+        
+        return Int(txId)
+    }
+    
+    func ensureParams(spend: URL, output: URL) -> Bool {
+        let readableSpend = FileManager.default.isReadableFile(atPath: spend.path)
+        let readableOutput = FileManager.default.isReadableFile(atPath: output.path)
+        
+        return readableSpend && readableOutput // Todo: change this to something that makes sense
+    }
+    
+    /**
+    Fetch the Transaction Entity from the encoded representation
+    - Parameter encodedTransaction: The encoded transaction to expand
+    - Returns: a TransactionEntity based on the given Encoded Transaction
+    - Throws: a TransactionEncoderError
+    */
+    func expandEncodedTransaction(_ encodedTransaction: EncodedTransaction) throws -> TransactionEntity {
+        guard let transaction = try? repository.findBy(rawId: encodedTransaction.transactionId) else {
+            throw TransactionEncoderError.couldNotExpand(txId: encodedTransaction.transactionId)
+        }
+        return transaction
+    }
+}

package/ios/ZCashLightClientKit/Utils/Bundle+module.swift

@@ -0,0 +1,30 @@
+// N.B This file is copied from the one that SPM generates to give a
+// `Bundle.module` variable. Using the macro we include this only for non-SPM
+// distribution methods, which we equate to "CocoaPods".
+// We use CocoaPods' "Resource Bundles" to copy the resources that we need and
+// we have called our main one "Resources" (see the podspec file), hence the hardcoded name.
+#if !SWIFT_PACKAGE
+import class Foundation.Bundle
+
+private class BundleFinder {}
+
+extension Foundation.Bundle {
+  /// Returns the resource bundle associated with the current Swift module.
+  static var module: Bundle = {
+    let bundleName = "Resources"
+
+    let candidates = [
+      // Bundle should be present here when the package is linked into a framework.
+      Bundle(for: BundleFinder.self).resourceURL
+    ]
+
+    for candidate in candidates {
+      let bundlePath = candidate?.appendingPathComponent(bundleName + ".bundle")
+      if let bundle = bundlePath.flatMap(Bundle.init(url:)) {
+        return bundle
+      }
+    }
+    fatalError("unable to find bundle named Resources")
+  }()
+}
+#endif

package/ios/ZCashLightClientKit/Utils/LoggingProxy.swift

@@ -0,0 +1,47 @@
+//
+//  LoggingProxy.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 3/6/20.
+//
+
+import Foundation
+
+/**
+Represents what's expected from a logging entity
+*/
+public protocol Logger {
+    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)
+    
+    func warn(_ message: String, file: StaticString, function: StaticString, line: Int)
+    
+    func error(_ message: String, file: StaticString, function: StaticString, line: Int)
+}
+
+var logger: Logger?
+
+enum LoggerProxy {
+    static func debug(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
+        logger?.debug(message, file: file, function: function, line: line)
+    }
+    
+    static func info(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
+        logger?.info(message, file: file, function: function, line: line)
+    }
+    
+    static func event(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
+        logger?.event(message, file: file, function: function, line: line)
+    }
+    
+    static func warn(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
+        logger?.warn(message, file: file, function: function, line: line)
+    }
+    
+    static func error(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
+        logger?.error(message, file: file, function: function, line: line)
+    }
+}

package/ios/ZCashLightClientKit/Utils/SaplingParameterDownloader.swift

@@ -0,0 +1,124 @@
+//
+//  SaplingParameterDownloader.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 10/7/20.
+//
+
+import Foundation
+/**
+Helper class to handle the download of Sapling parameters
+*/
+public enum SaplingParameterDownloader {
+    public enum Errors: Error {
+        case invalidURL(url: String)
+        case failed(error: Error)
+    }
+    
+    /**
+    Download a Spend parameter from default host and stores it at given URL
+    - Parameters:
+        - at: The destination URL for the download
+        - result: block to handle the download success or error
+    */
+    public static func downloadSpendParameter(_ at: URL, result: @escaping (Result<URL, Error>) -> Void) {
+        guard let url = URL(string: spendParamsURLString) else {
+            result(.failure(Errors.invalidURL(url: spendParamsURLString)))
+            return
+        }
+
+        downloadFileWithRequest(URLRequest(url: url), at: at, result: result)
+    }
+    /**
+    Download an Output parameter from default host and stores it at given URL
+    - Parameters:
+        - at: The destination URL for the download
+        - result: block to handle the download success or error
+    */
+    public static func downloadOutputParameter(_ at: URL, result: @escaping (Result<URL, Error>) -> Void) {
+        guard let url = URL(string: outputParamsURLString) else {
+            result(.failure(Errors.invalidURL(url: outputParamsURLString)))
+            return
+        }
+
+        downloadFileWithRequest(URLRequest(url: url), at: at, result: result)
+    }
+    
+    private static func downloadFileWithRequest(_ request: URLRequest, at destination: URL, result: @escaping (Result<URL, Error>) -> Void) {
+        let task = URLSession.shared.downloadTask(with: request) { url, _, error in
+            if let error = error {
+                result(.failure(Errors.failed(error: error)))
+                return
+            } else if let localUrl = url {
+                do {
+                    try FileManager.default.moveItem(at: localUrl, to: destination)
+                    result(.success(destination))
+                } catch {
+                    result(.failure(error))
+                }
+            }
+        }
+
+        task.resume()
+    }
+    /**
+    Downloads the parameters if not present and provides the resulting URLs for both parameters
+    - Parameters:
+        - spendURL: URL to check whether the parameter is already downloaded
+        - outputURL: URL to check whether the parameter is already downloaded
+        - result: block to handle success or error
+    */
+    public static func downloadParamsIfnotPresent(
+        spendURL: URL,
+        outputURL: URL,
+        result: @escaping (Result<(spend: URL, output: URL), Error>) -> Void
+    ) {
+        ensureSpendParameter(at: spendURL) { spendResult in
+            switch spendResult {
+            case .success(let spendResultURL):
+                ensureOutputParameter(at: outputURL) { outputResult in
+                    switch outputResult {
+                    case .success(let outputResultURL):
+                        result(.success((spendResultURL, outputResultURL)))
+                    case .failure(let outputResultError):
+                        result(.failure(Errors.failed(error: outputResultError)))
+                    }
+                }
+            case .failure(let spendResultError):
+                result(.failure(Errors.failed(error: spendResultError)))
+            }
+        }
+    }
+    
+    static func ensureSpendParameter(at url: URL, result: @escaping (Result<URL, Error>) -> Void) {
+        if isFilePresent(url: url) {
+            DispatchQueue.global().async {
+                result(.success(url))
+            }
+        } else {
+            downloadSpendParameter(url, result: result)
+        }
+    }
+    
+    static func ensureOutputParameter(at url: URL, result: @escaping (Result<URL, Error>) -> Void) {
+        if isFilePresent(url: url) {
+            DispatchQueue.global().async {
+                result(.success(url))
+            }
+        } else {
+            downloadOutputParameter(url, result: result)
+        }
+    }
+    
+    static func isFilePresent(url: URL) -> Bool {
+        (try? FileManager.default.attributesOfItem(atPath: url.path)) != nil
+    }
+    
+    public static var spendParamsURLString: String {
+        return ZcashSDK.cloudParameterURL + ZcashSDK.spendParamFilename
+    }
+    
+    public static var outputParamsURLString: String {
+        return ZcashSDK.cloudParameterURL + ZcashSDK.outputParamFilename
+    }
+}

package/ios/libzcashlc.xcframework/Info.plist

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>libzcashlc.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+		<dict>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64_x86_64-simulator</string>
+			<key>LibraryPath</key>
+			<string>libzcashlc.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>x86_64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

package/ios/react-native-zcash-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTEventEmitter.h>
+#include "ZCashLightClientKit/Rust/zcashlc.h"

package/ios/react-native-zcash.xcodeproj/project.pbxproj

@@ -0,0 +1 @@
+// Placeholder so react-native autolinking can find us.

package/lib/scripts/copyCheckpoints.d.ts

@@ -0,0 +1,5 @@
+import { Disklet } from 'disklet';
+/**
+ * Copies checkpoints over from the Android side to the iOS side.
+ */
+export declare function copyCheckpoints(disklet: Disklet): Promise<void>;

package/lib/scripts/updateSources.d.ts

@@ -0,0 +1 @@
+export {};