react-native-zcash 0.3.4 → 0.4.0

package/ios/ZCashLightClientKit/Tool/DerivationTool.swift

@@ -0,0 +1,207 @@
+//
+//  DerivationTool.swift
+//  Pods
+//
+//  Created by Francisco Gindre on 10/8/20.
+//
+
+import Combine
+import Foundation
+
+public protocol KeyValidation {
+    func isValidUnifiedFullViewingKey(_ ufvk: String) -> Bool
+    func isValidTransparentAddress(_ tAddress: String) -> Bool
+    func isValidSaplingAddress(_ zAddress: String) -> Bool
+    func isValidSaplingExtendedSpendingKey(_ extsk: String) -> Bool
+    func isValidUnifiedAddress(_ unifiedAddress: String) -> Bool
+}
+
+public protocol KeyDeriving {
+    /// Given the seed bytes tand the account index, return the UnifiedSpendingKey
+    /// - Parameter seed: `[Uint8]` seed bytes
+    /// - Parameter accountNumber: `Int` with the account number
+    /// - Throws:
+    ///     - `derivationToolSpendingKeyInvalidAccount` if the `accountIndex` is invalid.
+    ///     - some `ZcashError.rust*` error if the derivation fails.
+    /// - Returns a `UnifiedSpendingKey`
+    func deriveUnifiedSpendingKey(seed: [UInt8], accountIndex: Int) throws -> UnifiedSpendingKey
+
+    /// Given a spending key, return the associated viewing key.
+    /// - Parameter spendingKey: the `UnifiedSpendingKey` from which to derive the `UnifiedFullViewingKey` from.
+    /// - Throws: some `ZcashError.rust*` error if the derivation fails.
+    /// - Returns: the viewing key that corresponds to the spending key.
+    func deriveUnifiedFullViewingKey(from spendingKey: UnifiedSpendingKey) throws -> UnifiedFullViewingKey
+
+    /// Extracts the `SaplingAddress` from the given `UnifiedAddress`
+    /// - Parameter address: the `UnifiedAddress`
+    /// - Throws: some `ZcashError.rust*` error if the derivation fails.
+    func saplingReceiver(from unifiedAddress: UnifiedAddress) throws -> SaplingAddress
+
+    /// Extracts the `TransparentAddress` from the given `UnifiedAddress`
+    /// - Parameter address: the `UnifiedAddress`
+    /// - Throws: some `ZcashError.rust*` error if the derivation fails.
+    func transparentReceiver(from unifiedAddress: UnifiedAddress) throws -> TransparentAddress
+
+    /// Extracts the `UnifiedAddress.ReceiverTypecodes` from the given `UnifiedAddress`
+    /// - Throws: some `ZcashError.rust*` error if the derivation fails.
+    /// - Parameter address: the `UnifiedAddress`
+    func receiverTypecodesFromUnifiedAddress(_ address: UnifiedAddress) throws -> [UnifiedAddress.ReceiverTypecodes]
+
+    static func getAddressMetadata(_ addr: String) -> AddressMetadata?
+}
+
+public class DerivationTool: KeyDeriving {
+    let backend: ZcashKeyDerivationBackendWelding
+    
+    public init(networkType: NetworkType) {
+        self.backend = ZcashKeyDerivationBackend(networkType: networkType)
+    }
+
+    public func saplingReceiver(from unifiedAddress: UnifiedAddress) throws -> SaplingAddress {
+        try backend.getSaplingReceiver(for: unifiedAddress)
+    }
+
+    public func transparentReceiver(from unifiedAddress: UnifiedAddress) throws -> TransparentAddress {
+        try backend.getTransparentReceiver(for: unifiedAddress)
+    }
+
+    public static func getAddressMetadata(_ addr: String) -> AddressMetadata? {
+        ZcashKeyDerivationBackend.getAddressMetadata(addr)
+    }
+
+    /// Given a spending key, return the associated viewing key.
+    /// - Parameter spendingKey: the `UnifiedSpendingKey` from which to derive the `UnifiedFullViewingKey` from.
+    /// - Returns: the viewing key that corresponds to the spending key.
+    public func deriveUnifiedFullViewingKey(from spendingKey: UnifiedSpendingKey) throws -> UnifiedFullViewingKey {
+        try backend.deriveUnifiedFullViewingKey(from: spendingKey)
+    }
+
+    /// Given a seed and a number of accounts, return the associated spending keys.
+    /// - Parameter seed: the seed from which to derive spending keys.
+    /// - Parameter numberOfAccounts: the number of accounts to use. Multiple accounts are not fully
+    /// supported so the default value of 1 is recommended.
+    /// - Returns: the spending keys that correspond to the seed, formatted as Strings.
+    public func deriveUnifiedSpendingKey(seed: [UInt8], accountIndex: Int) throws -> UnifiedSpendingKey {
+        guard accountIndex >= 0, let accountIndex = Int32(exactly: accountIndex) else { throw ZcashError.derivationToolSpendingKeyInvalidAccount }
+        return try backend.deriveUnifiedSpendingKey(from: seed, accountIndex: accountIndex)
+    }
+
+    public func receiverTypecodesFromUnifiedAddress(_ address: UnifiedAddress) throws -> [UnifiedAddress.ReceiverTypecodes] {
+        return try backend.receiverTypecodesOnUnifiedAddress(address.stringEncoded)
+            .map { UnifiedAddress.ReceiverTypecodes(typecode: $0) }
+    }
+}
+
+public struct AddressMetadata {
+    let networkType: NetworkType
+    let addressType: AddressType
+
+    public init(network: NetworkType, addrType: AddressType) {
+        self.networkType = network
+        self.addressType = addrType
+    }
+}
+
+extension DerivationTool: KeyValidation {
+    public func isValidUnifiedFullViewingKey(_ ufvk: String) -> Bool {
+        backend.isValidUnifiedFullViewingKey(ufvk)
+    }
+
+    public func isValidUnifiedAddress(_ unifiedAddress: String) -> Bool {
+        backend.isValidUnifiedAddress(unifiedAddress)
+    }
+    
+    public func isValidTransparentAddress(_ tAddress: String) -> Bool {
+        backend.isValidTransparentAddress(tAddress)
+    }
+    
+    public func isValidSaplingAddress(_ zAddress: String) -> Bool {
+        backend.isValidSaplingAddress(zAddress)
+    }
+
+    public func isValidSaplingExtendedSpendingKey(_ extsk: String) -> Bool {
+        backend.isValidSaplingExtendedSpendingKey(extsk)
+    }
+}
+
+extension TransparentAddress {
+    /// This constructor is for internal use for Strings encodings that are assumed to be
+    /// already validated by another function. only for internal use. Unless you are
+    /// constructing an address from a primitive function of the FFI, you probably
+    /// shouldn't be using this.
+    init(validatedEncoding: String) {
+        self.encoding = validatedEncoding
+    }
+}
+
+extension SaplingAddress {
+    /// This constructor is for internal use for Strings encodings that are assumed to be
+    /// already validated by another function. only for internal use. Unless you are
+    /// constructing an address from a primitive function of the FFI, you probably
+    /// shouldn't be using this.
+    init(validatedEncoding: String) {
+        self.encoding = validatedEncoding
+    }
+}
+
+extension UnifiedAddress {
+    /// This constructor is for internal use for Strings encodings that are assumed to be
+    /// already validated by another function. only for internal use. Unless you are
+    /// constructing an address from a primitive function of the FFI, you probably
+    /// shouldn't be using this..
+    init(validatedEncoding: String, networkType: NetworkType) {
+        self.encoding = validatedEncoding
+        self.networkType = networkType
+    }
+}
+
+extension UnifiedFullViewingKey {
+    /// This constructor is for internal use for Strings encodings that are assumed to be
+    /// already validated by another function. only for internal use. Unless you are
+    /// constructing an address from a primitive function of the FFI, you probably
+    /// shouldn't be using this.
+    init(validatedEncoding: String, account: UInt32) {
+        self.encoding = validatedEncoding
+        self.account = account
+    }
+}
+
+extension SaplingExtendedFullViewingKey {
+    /// This constructor is for internal use for Strings encodings that are assumed to be
+    /// already validated by another function. only for internal use. Unless you are
+    /// constructing an address from a primitive function of the FFI, you probably
+    /// shouldn't be using this.
+    init(validatedEncoding: String) {
+        self.encoding = validatedEncoding
+    }
+}
+
+extension SaplingExtendedSpendingKey {
+    /// This constructor is for internal use for Strings encodings that are assumed to be
+    /// already validated by another function. only for internal use. Unless you are
+    /// constructing an address from a primitive function of the FFI, you probably
+    /// shouldn't be using this.
+    init(validatedEncoding: String) {
+        self.encoding = validatedEncoding
+    }
+}
+
+public extension UnifiedSpendingKey {
+    func map<T>(_ transform: (UnifiedSpendingKey) throws -> T) rethrows -> T {
+        try transform(self)
+    }
+}
+
+public extension UnifiedAddress {
+    /// Extracts the sapling receiver from this UA if available
+    /// - Returns: an `Optional<SaplingAddress>`
+    func saplingReceiver() throws -> SaplingAddress {
+        try DerivationTool(networkType: networkType).saplingReceiver(from: self)
+    }
+
+    /// Extracts the transparent receiver from this UA if available
+    /// - Returns: an `Optional<TransparentAddress>`
+    func transparentReceiver() throws -> TransparentAddress {
+        try DerivationTool(networkType: networkType).transparentReceiver(from: self)
+    }
+}

package/ios/ZCashLightClientKit/Transaction/TransactionEncoder.swift

@@ -0,0 +1,66 @@
+//
+//  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)
+    case submitError(code: Int, message: String)
+}
+
+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).
+    ///
+    /// - Parameters:
+    /// - Parameter spendingKey: a `UnifiedSpendingKey` containing the spending key
+    /// - Parameter zatoshi: the amount to send in `Zatoshi`
+    /// - Parameter to: string containing the recipient address
+    /// - Parameter MemoBytes: string containing the memo (optional)
+    /// - Parameter accountIndex: index of the account that will be used to send the funds
+    /// - Throws:
+    ///     - `walletTransEncoderCreateTransactionMissingSaplingParams` if the sapling parameters aren't downloaded.
+    ///     - Some `ZcashError.rust*` if the creation of transaction fails.
+    func createTransaction(
+        spendingKey: UnifiedSpendingKey,
+        zatoshi: Zatoshi,
+        to address: String,
+        memoBytes: MemoBytes?,
+        from accountIndex: Int
+    ) async throws -> ZcashTransaction.Overview
+    
+    /// Creates a transaction that will attempt to shield transparent funds that are present on the blocks cache .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).
+    ///
+    /// - Parameters:
+    /// - Parameter spendingKey: `UnifiedSpendingKey` to spend the UTXOs
+    /// - Parameter memoBytes: containing the memo (optional)
+    /// - Parameter accountIndex: index of the account that will be used to send the funds
+    /// - Throws:
+    ///     - `walletTransEncoderShieldFundsMissingSaplingParams` if the sapling parameters aren't downloaded.
+    ///     - Some `ZcashError.rust*` if the creation of transaction fails.
+    func createShieldingTransaction(
+        spendingKey: UnifiedSpendingKey,
+        shieldingThreshold: Zatoshi,
+        memoBytes: MemoBytes?,
+        from accountIndex: Int
+    ) async throws -> ZcashTransaction.Overview
+
+    /// submits a transaction to the Zcash peer-to-peer network.
+    /// - Parameter transaction: a transaction overview
+    func submit(transaction: EncodedTransaction) async throws
+
+    func closeDBConnection()
+}

package/ios/ZCashLightClientKit/Transaction/WalletTransactionEncoder.swift

@@ -0,0 +1,165 @@
+//
+//  WalletTransactionEncoder.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 11/20/19.
+//
+
+import Foundation
+
+class WalletTransactionEncoder: TransactionEncoder {
+    let lightWalletService: LightWalletService
+    let rustBackend: ZcashRustBackendWelding
+    let repository: TransactionRepository
+    let logger: Logger
+
+    private let outputParamsURL: URL
+    private let spendParamsURL: URL
+    private let dataDbURL: URL
+    private let fsBlockDbRoot: URL
+    private let networkType: NetworkType
+    
+    init(
+        rustBackend: ZcashRustBackendWelding,
+        dataDb: URL,
+        fsBlockDbRoot: URL,
+        service: LightWalletService,
+        repository: TransactionRepository,
+        outputParams: URL,
+        spendParams: URL,
+        networkType: NetworkType,
+        logger: Logger
+    ) {
+        self.rustBackend = rustBackend
+        self.dataDbURL = dataDb
+        self.fsBlockDbRoot = fsBlockDbRoot
+        self.lightWalletService = service
+        self.repository = repository
+        self.outputParamsURL = outputParams
+        self.spendParamsURL = spendParams
+        self.networkType = networkType
+        self.logger = logger
+    }
+    
+    convenience init(initializer: Initializer) {
+        self.init(
+            rustBackend: initializer.rustBackend,
+            dataDb: initializer.dataDbURL,
+            fsBlockDbRoot: initializer.fsBlockDbRoot,
+            service: initializer.lightWalletService,
+            repository: initializer.transactionRepository,
+            outputParams: initializer.outputParamsURL,
+            spendParams: initializer.spendParamsURL,
+            networkType: initializer.network.networkType,
+            logger: initializer.logger
+        )
+    }
+    
+    func createTransaction(
+        spendingKey: UnifiedSpendingKey,
+        zatoshi: Zatoshi,
+        to address: String,
+        memoBytes: MemoBytes?,
+        from accountIndex: Int
+    ) async throws -> ZcashTransaction.Overview {
+        let txId = try await createSpend(
+            spendingKey: spendingKey,
+            zatoshi: zatoshi,
+            to: address,
+            memoBytes: memoBytes,
+            from: accountIndex
+        )
+
+        logger.debug("transaction id: \(txId)")
+        return try await repository.find(id: txId)
+    }
+    
+    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 = try await rustBackend.createToAddress(
+            usk: spendingKey,
+            to: address,
+            value: zatoshi.amount,
+            memo: memoBytes
+        )
+
+        return Int(txId)
+    }
+    
+    func createShieldingTransaction(
+        spendingKey: UnifiedSpendingKey,
+        shieldingThreshold: Zatoshi,
+        memoBytes: MemoBytes?,
+        from accountIndex: Int
+    ) async throws -> ZcashTransaction.Overview {
+        let txId = try await createShieldingSpend(
+            spendingKey: spendingKey,
+            shieldingThreshold: shieldingThreshold,
+            memo: memoBytes,
+            accountIndex: accountIndex
+        )
+        
+        logger.debug("transaction id: \(txId)")
+        return try await repository.find(id: txId)
+    }
+
+    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 = try await rustBackend.shieldFunds(
+            usk: spendingKey,
+            memo: memo,
+            shieldingThreshold: shieldingThreshold
+        )
+                
+        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)
+        
+        // TODO: [#713] change this to something that makes sense, https://github.com/zcash/ZcashLightClientKit/issues/713
+        return readableSpend && readableOutput
+    }
+
+    func closeDBConnection() {
+        self.repository.closeDBConnection()
+    }
+}
+
+extension ZcashTransaction.Overview {
+    func encodedTransaction() throws -> EncodedTransaction {
+        guard let raw else {
+            throw TransactionEncoderError.notEncoded(transactionId: self.id)
+        }
+
+        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
+    }
+}