react-native-zcash 0.3.5 → 0.4.1

package/ios/ZCashLightClientKit/Transaction/WalletTransactionEncoder.swift

@@ -8,209 +8,158 @@
 import Foundation
 
 class WalletTransactionEncoder: TransactionEncoder {
-    var rustBackend: ZcashRustBackendWelding.Type
-    var repository: TransactionRepository
-    var queue: DispatchQueue
+    let lightWalletService: LightWalletService
+    let rustBackend: ZcashRustBackendWelding
+    let repository: TransactionRepository
+    let logger: Logger
 
-    private var outputParamsURL: URL
-    private var spendParamsURL: URL
-    private var dataDbURL: URL
-    private var cacheDbURL: URL
-    private var networkType: NetworkType
+    private let outputParamsURL: URL
+    private let spendParamsURL: URL
+    private let dataDbURL: URL
+    private let fsBlockDbRoot: URL
+    private let networkType: NetworkType
     
     init(
-        rust: ZcashRustBackendWelding.Type,
+        rustBackend: ZcashRustBackendWelding,
         dataDb: URL,
-        cacheDb: URL,
+        fsBlockDbRoot: URL,
+        service: LightWalletService,
         repository: TransactionRepository,
         outputParams: URL,
         spendParams: URL,
-        networkType: NetworkType
+        networkType: NetworkType,
+        logger: Logger
     ) {
-        self.rustBackend = rust
+        self.rustBackend = rustBackend
         self.dataDbURL = dataDb
-        self.cacheDbURL = cacheDb
+        self.fsBlockDbRoot = fsBlockDbRoot
+        self.lightWalletService = service
         self.repository = repository
         self.outputParamsURL = outputParams
         self.spendParamsURL = spendParams
         self.networkType = networkType
-        self.queue = DispatchQueue(label: "wallet.transaction.encoder.serial.queue")
+        self.logger = logger
     }
     
     convenience init(initializer: Initializer) {
         self.init(
-            rust: initializer.rustBackend,
+            rustBackend: initializer.rustBackend,
             dataDb: initializer.dataDbURL,
-            cacheDb: initializer.cacheDbURL,
+            fsBlockDbRoot: initializer.fsBlockDbRoot,
+            service: initializer.lightWalletService,
             repository: initializer.transactionRepository,
             outputParams: initializer.outputParamsURL,
             spendParams: initializer.spendParamsURL,
-            networkType: initializer.network.networkType
+            networkType: initializer.network.networkType,
+            logger: initializer.logger
         )
     }
     
     func createTransaction(
-        spendingKey: String,
-        zatoshi: Int,
+        spendingKey: UnifiedSpendingKey,
+        zatoshi: Zatoshi,
         to address: String,
-        memo: String?,
+        memoBytes: MemoBytes?,
         from accountIndex: Int
-    ) throws -> EncodedTransaction {
-        let txId = try createSpend(
+    ) async throws -> ZcashTransaction.Overview {
+        let txId = try await createSpend(
             spendingKey: spendingKey,
             zatoshi: zatoshi,
             to: address,
-            memo: memo,
+            memoBytes: memoBytes,
             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))
-            }
-        }
+        logger.debug("transaction id: \(txId)")
+        return try await repository.find(id: txId)
     }
     
-    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
+    func createSpend(
+        spendingKey: UnifiedSpendingKey,
+        zatoshi: Zatoshi,
+        to address: String,
+        memoBytes: MemoBytes?,
+        from accountIndex: Int
+    ) async throws -> Int {
+        guard ensureParams(spend: self.spendParamsURL, output: self.outputParamsURL) else {
+            throw ZcashError.walletTransEncoderCreateTransactionMissingSaplingParams
         }
-                
-        let txId = rustBackend.createToAddress(
-            dbData: self.dataDbURL,
-            account: Int32(accountIndex),
-            extsk: spendingKey,
+
+        let txId = try await rustBackend.createToAddress(
+            usk: spendingKey,
             to: address,
-            value: Int64(zatoshi),
-            memo: memo,
-            spendParamsPath: self.spendParamsURL.path,
-            outputParamsPath: self.outputParamsURL.path,
-            networkType: networkType
+            value: zatoshi.amount,
+            memo: memoBytes
         )
-        
-        guard txId > 0 else {
-            throw rustBackend.lastError() ?? RustWeldingError.genericError(message: "create spend failed")
-        }
-        
+
         return Int(txId)
     }
     
     func createShieldingTransaction(
-        spendingKey: String,
-        tSecretKey: String,
-        memo: String?,
+        spendingKey: UnifiedSpendingKey,
+        shieldingThreshold: Zatoshi,
+        memoBytes: MemoBytes?,
         from accountIndex: Int
-    ) throws -> EncodedTransaction {
-        let txId = try createShieldingSpend(
+    ) async throws -> ZcashTransaction.Overview {
+        let txId = try await createShieldingSpend(
             spendingKey: spendingKey,
-            tsk: tSecretKey,
-            memo: memo,
+            shieldingThreshold: shieldingThreshold,
+            memo: memoBytes,
             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")))
-        }
+        logger.debug("transaction id: \(txId)")
+        return try await repository.find(id: txId)
     }
-    
-    func createShieldingSpend(spendingKey: String, tsk: String, memo: String?, accountIndex: Int) throws -> Int {
-        guard ensureParams(spend: self.spendParamsURL, output: self.spendParamsURL) else {
-            throw TransactionEncoderError.missingParams
+
+    func createShieldingSpend(
+        spendingKey: UnifiedSpendingKey,
+        shieldingThreshold: Zatoshi,
+        memo: MemoBytes?,
+        accountIndex: Int
+    ) async throws -> Int {
+        guard ensureParams(spend: self.spendParamsURL, output: self.outputParamsURL) else {
+            throw ZcashError.walletTransEncoderShieldFundsMissingSaplingParams
         }
         
-        let txId = rustBackend.shieldFunds(
-            dbCache: self.cacheDbURL,
-            dbData: self.dataDbURL,
-            account: Int32(accountIndex),
-            tsk: tsk,
-            extsk: spendingKey,
+        let txId = try await rustBackend.shieldFunds(
+            usk: spendingKey,
             memo: memo,
-            spendParamsPath: self.spendParamsURL.path,
-            outputParamsPath: self.outputParamsURL.path,
-            networkType: networkType
+            shieldingThreshold: shieldingThreshold
         )
-        
-        guard txId > 0 else {
-            throw rustBackend.lastError() ?? RustWeldingError.genericError(message: "create spend failed")
-        }
-        
+                
         return Int(txId)
     }
-    
+
+    func submit(
+        transaction: EncodedTransaction
+    ) async throws {
+        let response = try await self.lightWalletService.submit(spendTransaction: transaction.raw)
+
+        guard response.errorCode >= 0 else {
+            throw TransactionEncoderError.submitError(code: Int(response.errorCode), message: response.errorMessage)
+        }
+    }
+
     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
+        // TODO: [#713] change this to something that makes sense, https://github.com/zcash/ZcashLightClientKit/issues/713
+        return readableSpend && readableOutput
     }
-    
-    /**
-    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)
+
+    func closeDBConnection() {
+        self.repository.closeDBConnection()
+    }
+}
+
+extension ZcashTransaction.Overview {
+    func encodedTransaction() throws -> EncodedTransaction {
+        guard let raw else {
+            throw TransactionEncoderError.notEncoded(transactionId: self.id)
         }
-        return transaction
+
+        return EncodedTransaction(transactionId: self.rawID, raw: raw)
     }
 }

package/ios/ZCashLightClientKit/Utils/AsyncToClosureGateway.swift

@@ -0,0 +1,46 @@
+//
+//  AsyncToClosureGateway.swift
+//  
+//
+//  Created by Michal Fousek on 03.04.2023.
+//
+
+import Foundation
+
+enum AsyncToClosureGateway {
+    static func executeAction(_ completion: @escaping () -> Void, action: @escaping () async -> Void) {
+        Task {
+            await action()
+            completion()
+        }
+    }
+
+    static func executeAction<R>(_ completion: @escaping (R) -> Void, action: @escaping () async -> R) {
+        Task {
+            let result = await action()
+            completion(result)
+        }
+    }
+
+    static func executeThrowingAction(_ completion: @escaping (Error?) -> Void, action: @escaping () async throws -> Void) {
+        Task {
+            do {
+                try await action()
+                completion(nil)
+            } catch {
+                completion(error)
+            }
+        }
+    }
+
+    static func executeThrowingAction<R>(_ completion: @escaping (Result<R, Error>) -> Void, action: @escaping () async throws -> R) {
+        Task {
+            do {
+                let result = try await action()
+                completion(.success(result))
+            } catch {
+                completion(.failure(error))
+            }
+        }
+    }
+}

package/ios/ZCashLightClientKit/Utils/AsyncToCombineGateway.swift

@@ -0,0 +1,59 @@
+//
+//  AsyncToCombineGateway.swift
+//  
+//
+//  Created by Michal Fousek on 03.04.2023.
+//
+
+import Combine
+import Foundation
+
+enum AsyncToCombineGateway {
+    static func executeAction(action: @escaping () async -> Void) -> CompletablePublisher<Never> {
+        let subject = PassthroughSubject<Void, Never>()
+        Task {
+            await action()
+            subject.send(completion: .finished)
+        }
+        return subject.eraseToAnyPublisher()
+    }
+
+    static func executeAction<R>(action: @escaping () async -> R) -> SinglePublisher<R, Never> {
+        let subject = PassthroughSubject<R, Never>()
+        Task {
+            let result = await action()
+            subject.send(result)
+            subject.send(completion: .finished)
+        }
+        return subject.eraseToAnyPublisher()
+    }
+
+    static func executeThrowingAction(action: @escaping () async throws -> Void) -> CompletablePublisher<Error> {
+        let subject = PassthroughSubject<Void, Error>()
+        Task {
+            do {
+                try await action()
+                subject.send(completion: .finished)
+            } catch {
+                subject.send(completion: .failure(error))
+            }
+        }
+
+        return subject.eraseToAnyPublisher()
+    }
+
+    static func executeThrowingAction<R>(action: @escaping () async throws -> R) -> SinglePublisher<R, Error> {
+        let subject = PassthroughSubject<R, Error>()
+        Task {
+            do {
+                let result = try await action()
+                subject.send(result)
+                subject.send(completion: .finished)
+            } catch {
+                subject.send(completion: .failure(error))
+            }
+        }
+
+        return subject.eraseToAnyPublisher()
+    }
+}

package/ios/ZCashLightClientKit/Utils/Clamped.swift

@@ -0,0 +1,32 @@
+//
+//  Clamped.swift
+//  secant-testnet
+//
+//  Created by Francisco Gindre on 10/20/21.
+//
+// credits: https://iteo.medium.com/swift-property-wrappers-how-to-use-them-right-77095817d1b
+import Foundation
+
+/**
+Limits a value to an enclosing range
+*/
+@propertyWrapper
+public struct Clamped<Value: Comparable> {
+    private var value: Value
+    private let range: ClosedRange<Value>
+    public var wrappedValue: Value {
+        get { value }
+        set { value = clamp(newValue, using: range) }
+    }
+
+    init(wrappedValue: Value, _ range: ClosedRange<Value>) {
+        self.value = wrappedValue
+        self.range = range
+        
+        value = clamp(wrappedValue, using: range)
+    }
+    
+    private func clamp(_ value: Value, using range: ClosedRange<Value>) -> Value {
+        min(range.upperBound, max(range.lowerBound, value))
+    }
+}

package/ios/ZCashLightClientKit/Utils/DIContainer.swift

@@ -0,0 +1,86 @@
+//
+//  DIContainer.swift
+//  
+//
+//  Created by Michal Fousek on 01.05.2023.
+//
+
+import Foundation
+
+/// This class represents depedency injection containers.
+class DIContainer {
+    /// Structure that represents one registered dependency.
+    struct Dependency {
+        /// Closure which creates instance of the dependency.
+        let factory: (DIContainer) -> Any
+        /// Indicates if dependency is singleton. If this is `true` then `DIContainer` creates only one instance of this dependency and returns
+        /// it every time `resolve()` for the dependency is called.
+        let isSingleton: Bool
+        /// If the dependency is singleton then instance is stored here.
+        let instance: Any?
+    }
+
+    /// If this is `true` then `mockedDependencies` is used first to resolve dependencies. This is used for mocking in tests.
+    var isTestEnvironment = false
+
+    private let lock = NSRecursiveLock()
+    /// Dependencies are stored here.
+    private var dependencies: [String: Dependency] = [:]
+    /// Mocked dependencies are stored here.
+    private var mockedDependencies: [String: Dependency] = [:]
+
+    init() { }
+
+    private func key<T>(for type: T.Type) -> String {
+        return String(describing: T.self)
+    }
+
+    func register<T>(type: T.Type, isSingleton: Bool, factory: @escaping (DIContainer) -> T) {
+        lock.lock()
+        let key = self.key(for: type)
+        let depedency = Dependency(factory: factory, isSingleton: isSingleton, instance: nil)
+        dependencies[key] = depedency
+        lock.unlock()
+    }
+
+    func mock<T>(type: T.Type, isSingleton: Bool, factory: @escaping (DIContainer) -> T) {
+        lock.lock()
+        let key = self.key(for: type)
+        let depedency = Dependency(factory: factory, isSingleton: isSingleton, instance: nil)
+        mockedDependencies[key] = depedency
+        lock.unlock()
+    }
+
+    func resolve<T>(_ type: T.Type) -> T {
+        lock.lock()
+        defer { lock.unlock() }
+        let key = self.key(for: type)
+
+        let possibleDependency = (isTestEnvironment ? mockedDependencies[key] : dependencies[key]) ?? dependencies[key]
+        guard let dependency = possibleDependency else {
+            // When dependency is resolved before it's registered then the app crashes. It would be possible to not crash and throw some error here.
+            // But it complicates the rest of the code. And maybe it doesn't make sense because this kind of error is not recoverable. It can be fixed
+            // only by updating the code.
+            fatalError("Doesn't have registered dependency for type \(type).")
+        }
+
+        let instance: Any
+        if dependency.isSingleton, let singleton = dependency.instance {
+            instance = singleton
+        } else {
+            instance = dependency.factory(self)
+        }
+
+        if dependency.isSingleton && dependency.instance == nil {
+            dependencies[key] = Dependency(factory: dependency.factory, isSingleton: dependency.isSingleton, instance: instance)
+        }
+
+        guard let instance = instance as? T else {
+            // When dependency is resolved but instance of created depedency is different than expected type the app crashes. It would be possible to
+            // not crash and throw some error here. But it complicates the rest of the code. And maybe it doesn't make sense because this kind of
+            // error is not recoverable. It can be fixed only by updating the code.
+            fatalError("Getting dependency for type \(type) but created instance is \(instance)")
+        }
+        return instance
+    }
+}

package/ios/ZCashLightClientKit/Utils/GenericActor.swift

@@ -0,0 +1,18 @@
+//
+//  GenericActor.swift
+//  
+//
+//  Created by Michal Fousek on 20.03.2023.
+//
+
+import Foundation
+
+actor GenericActor<T> {
+    var value: T
+    init(_ value: T) { self.value = value }
+    func update(_ newValue: T) async -> T {
+        let oldValue = value
+        value = newValue
+        return oldValue
+    }
+}

package/ios/ZCashLightClientKit/Utils/LoggingProxy.swift

@@ -12,36 +12,37 @@ 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)
+extension Logger {
+    func debug(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
+        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)
+    func info(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
+        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)
+    func event(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
+        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)
+    func warn(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
+        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)
+    func error(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
+        error(message, file: file, function: function, line: line)
     }
 }
+
+/**
+A concrete logger implementation that logs nothing at all
+ */
+struct NullLogger: 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) {}
+}