react-native-zcash 0.3.5 → 0.4.1

package/ios/ZCashLightClientKit/Tool/DerivationTool.swift

@@ -5,340 +5,203 @@
 //  Created by Francisco Gindre on 10/8/20.
 //
 
+import Combine
 import Foundation
 
 public protocol KeyValidation {
-    func isValidExtendedViewingKey(_ extvk: String) throws -> Bool
-    
-    func isValidTransparentAddress(_ tAddress: String) throws -> Bool
-    
-    func isValidShieldedAddress(_ zAddress: String) throws -> Bool
+    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 a seed and a number of accounts, return the associated viewing keys.
-     
-    - Parameter seed: the seed from which to derive viewing 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 viewing keys that correspond to the seed, formatted as Strings.
-    */
-    func deriveViewingKeys(seed: [UInt8], numberOfAccounts: Int) throws -> [String]
+    /// 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 key from which to derive the viewing key.
-    
-    - Returns: the viewing key that corresponds to the spending key.
-    */
-    func deriveViewingKey(spendingKey: String) throws -> String
+    /// 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
 
-    /**
-    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.
-    */
-    func deriveSpendingKeys(seed: [UInt8], numberOfAccounts: Int) throws -> [String]
-    
-    /**
-    Given a seed and account index, return the associated address.
-     
-    - Parameter seed: the seed from which to derive the address.
-    - Parameter accountIndex: the index of the account to use for deriving the address. Multiple
-    accounts are not fully supported so the default value of 1 is recommended.
-     
-    - Returns: the address that corresponds to the seed and account index.
-    */
-    func deriveShieldedAddress(seed: [UInt8], accountIndex: Int) throws -> String
-    
-    /**
-    Given a viewing key string, return the associated address.
-     
-    - Parameter viewingKey: the viewing key to use for deriving the address. The viewing key is tied to
-        a specific account so no account index is required.
-     
-    - Returns: the address that corresponds to the viewing key.
-    */
-    func deriveShieldedAddress(viewingKey: String) throws -> String
-    
-    /**
-    Derives a transparent address  from seedbytes, specifying account and index
-    */
-    func deriveTransparentAddress(seed: [UInt8], account: Int, index: Int) throws -> String
-    
-    /**
-    Derives a SecretKey to spend transparent funds from a transparent secret key wif encoded
-    */
-    func deriveTransparentPrivateKey(seed: [UInt8], account: Int, index: Int) throws -> String
-    
-    /**
-    Derives a transparent address from the given transparent Secret Key
-    */
-    func deriveTransparentAddressFromPrivateKey(_ tsk: String) throws -> String
-    
-    func deriveTransparentAddressFromPublicKey(_ pubkey: String) throws -> String
-    
-    /**
-    derives unified viewing keys from seedbytes, specifying a number of accounts
-    - Returns an array of unified viewing key tuples.
-    */
-    func deriveUnifiedViewingKeysFromSeed(_ seed: [UInt8], numberOfAccounts: Int) throws -> [UnifiedViewingKey]
-    
-    /**
-    derives a Unified Address from a Unified Viewing Key
-    */
-    func deriveUnifiedAddressFromUnifiedViewingKey(_ uvk: UnifiedViewingKey) throws -> UnifiedAddress
-}
+    /// 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]
 
-public enum KeyDerivationErrors: Error {
-    case derivationError(underlyingError: Error)
-    case unableToDerive
-    case invalidInput
+    static func getAddressMetadata(_ addr: String) -> AddressMetadata?
 }
 
 public class DerivationTool: KeyDeriving {
-    var rustwelding: ZcashRustBackendWelding.Type = ZcashRustBackend.self
-    
-    var networkType: NetworkType
+    let backend: ZcashKeyDerivationBackendWelding
     
     public init(networkType: NetworkType) {
-        self.networkType = networkType
+        self.backend = ZcashKeyDerivationBackend(networkType: networkType)
     }
 
-    /**
-    Given a seed and a number of accounts, return the associated viewing keys.
-     
-    - Parameter seed: the seed from which to derive viewing 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 viewing keys that correspond to the seed, formatted as Strings.
-    */
-    public func deriveViewingKeys(seed: [UInt8], numberOfAccounts: Int) throws -> [String] {
-        guard numberOfAccounts > 0, let numberOfAccounts = Int32(exactly: numberOfAccounts) else {
-            throw KeyDerivationErrors.invalidInput
-        }
-        
-        do {
-            guard let keys = try rustwelding.deriveExtendedFullViewingKeys(seed: seed, accounts: numberOfAccounts, networkType: networkType) else {
-                throw KeyDerivationErrors.unableToDerive
-            }
-            return keys
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+    public func saplingReceiver(from unifiedAddress: UnifiedAddress) throws -> SaplingAddress {
+        try backend.getSaplingReceiver(for: unifiedAddress)
     }
-    
-    /**
-    Given a spending key, return the associated viewing key.
-    
-    - Parameter spendingKey: the key from which to derive the viewing key.
-    
-    - Returns: the viewing key that corresponds to the spending key.
-    */
-    public func deriveViewingKey(spendingKey: String) throws -> String {
-        do {
-            guard let key = try rustwelding.deriveExtendedFullViewingKey(spendingKey, networkType: networkType) else {
-                throw KeyDerivationErrors.unableToDerive
-            }
-            return key
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+
+    public func transparentReceiver(from unifiedAddress: UnifiedAddress) throws -> TransparentAddress {
+        try backend.getTransparentReceiver(for: unifiedAddress)
     }
-    
-    /**
-    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 deriveSpendingKeys(seed: [UInt8], numberOfAccounts: Int) throws -> [String] {
-        guard numberOfAccounts > 0, let numberOfAccounts = Int32(exactly: numberOfAccounts) else {
-            throw KeyDerivationErrors.invalidInput
-        }
-        do {
-            guard let keys = try rustwelding.deriveExtendedSpendingKeys(seed: seed, accounts: numberOfAccounts, networkType: networkType) else {
-                throw KeyDerivationErrors.unableToDerive
-            }
-            return keys
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+
+    public static func getAddressMetadata(_ addr: String) -> AddressMetadata? {
+        ZcashKeyDerivationBackend.getAddressMetadata(addr)
     }
-    
-    /**
-    Given a seed and account index, return the associated address.
-     
-    - Parameter seed: the seed from which to derive the address.
-    - Parameter accountIndex: the index of the account to use for deriving the address. Multiple
-    accounts are not fully supported so the default value of 1 is recommended.
-     
-    - Returns: the address that corresponds to the seed and account index.
-    */
-    public func deriveShieldedAddress(seed: [UInt8], accountIndex: Int) throws -> String {
-        guard accountIndex >= 0, let accountIndex = Int32(exactly: accountIndex) else {
-            throw KeyDerivationErrors.invalidInput
-        }
-        
-        do {
-            guard let address = try rustwelding.deriveShieldedAddressFromSeed(seed: seed, accountIndex: accountIndex, networkType: networkType) else {
-                throw KeyDerivationErrors.unableToDerive
-            }
-            return address
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+
+    /// 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 viewing key string, return the associated address.
-     
-    - Parameter viewingKey: the viewing key to use for deriving the address. The viewing key is tied to
-    a specific account so no account index is required.
-     
-    - Returns: the address that corresponds to the viewing key.
-    */
-    public func deriveShieldedAddress(viewingKey: String) throws -> String {
-        do {
-            guard let zaddr = try rustwelding.deriveShieldedAddressFromViewingKey(viewingKey, networkType: networkType) else {
-                throw KeyDerivationErrors.unableToDerive
-            }
-            return zaddr
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+
+    /// 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 deriveTransparentAddress(seed: [UInt8], account: Int = 0, index: Int = 0) throws -> String {
-        do {
-            guard let zaddr = try rustwelding.deriveTransparentAddressFromSeed(
-                seed: seed,
-                account: account,
-                index: index,
-                networkType: networkType
-            ) else {
-                throw KeyDerivationErrors.unableToDerive
-            }
-            return zaddr
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+
+    public func receiverTypecodesFromUnifiedAddress(_ address: UnifiedAddress) throws -> [UnifiedAddress.ReceiverTypecodes] {
+        return try backend.receiverTypecodesOnUnifiedAddress(address.stringEncoded)
+            .map { UnifiedAddress.ReceiverTypecodes(typecode: $0) }
     }
-    
-    public func deriveUnifiedViewingKeysFromSeed(_ seed: [UInt8], numberOfAccounts: Int) throws -> [UnifiedViewingKey] {
-        guard numberOfAccounts > 0 else {
-            throw KeyDerivationErrors.invalidInput
-        }
-        do {
-            return try rustwelding.deriveUnifiedViewingKeyFromSeed(seed, numberOfAccounts: numberOfAccounts, networkType: networkType)
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+}
+
+public struct AddressMetadata {
+    let networkType: NetworkType
+    let addressType: AddressType
+
+    public init(network: NetworkType, addrType: AddressType) {
+        self.networkType = network
+        self.addressType = addrType
     }
-    
-    /**
-    derives a Unified Address from a Unified Viewing Key
-    */
-    public func deriveUnifiedAddressFromUnifiedViewingKey(_ uvk: UnifiedViewingKey) throws -> UnifiedAddress {
-        do {
-            let tAddress = try deriveTransparentAddressFromPublicKey(uvk.extpub)
-            let zAddress = try deriveShieldedAddress(viewingKey: uvk.extfvk)
-            return ConcreteUnifiedAddress(tAddress: tAddress, zAddress: zAddress)
-        } catch {
-            throw KeyDerivationErrors.unableToDerive
-        }
+}
+
+extension DerivationTool: KeyValidation {
+    public func isValidUnifiedFullViewingKey(_ ufvk: String) -> Bool {
+        backend.isValidUnifiedFullViewingKey(ufvk)
+    }
+
+    public func isValidUnifiedAddress(_ unifiedAddress: String) -> Bool {
+        backend.isValidUnifiedAddress(unifiedAddress)
     }
     
-    public func deriveTransparentAddressFromPublicKey(_ pubkey: String) throws -> String {
-        guard !pubkey.isEmpty else {
-            throw KeyDerivationErrors.invalidInput
-        }
-        
-        do {
-            return try rustwelding.derivedTransparentAddressFromPublicKey(pubkey, networkType: networkType)
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+    public func isValidTransparentAddress(_ tAddress: String) -> Bool {
+        backend.isValidTransparentAddress(tAddress)
     }
     
-    /**
-    Derives the transparent funds private key from the given seed
-    - Throws:
-    -  KeyDerivationErrors.derivationError with the underlying error when it fails
-    - KeyDerivationErrors.unableToDerive when there's an unknown error
-    */
-    public func deriveTransparentPrivateKey(seed: [UInt8], account: Int = 0, index: Int = 0) throws -> String {
-        do {
-            guard let seedKey = try rustwelding.deriveTransparentPrivateKeyFromSeed(
-                seed: seed,
-                account: account,
-                index: index,
-                networkType: networkType
-            ) else {
-                throw KeyDerivationErrors.unableToDerive
-            }
-            return seedKey
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+    public func isValidSaplingAddress(_ zAddress: String) -> Bool {
+        backend.isValidSaplingAddress(zAddress)
+    }
+
+    public func isValidSaplingExtendedSpendingKey(_ extsk: String) -> Bool {
+        backend.isValidSaplingExtendedSpendingKey(extsk)
     }
 }
 
-extension DerivationTool: KeyValidation {
-    public func isValidExtendedViewingKey(_ extvk: String) throws -> Bool {
-        do {
-            return try rustwelding.isValidExtendedFullViewingKey(extvk, networkType: networkType)
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+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
     }
-    
-    public func isValidTransparentAddress(_ tAddress: String) throws -> Bool {
-        do {
-            return try rustwelding.isValidTransparentAddress(tAddress, networkType: networkType)
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+}
+
+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
     }
-    
-    public func isValidShieldedAddress(_ zAddress: String) throws -> Bool {
-        do {
-            return try rustwelding.isValidShieldedAddress(zAddress, networkType: networkType)
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+}
+
+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
     }
-    
-    /**
-    Derives the transparent address from a WIF Private Key
-    - Throws:
-        - KeyDerivationErrors.derivationError with the underlying error when it fails
-        - KeyDerivationErrors.unableToDerive when there's an unknown error
-    */
-    public func deriveTransparentAddressFromPrivateKey(_ tsk: String) throws -> String {
-        do {
-            guard let tAddr = try rustwelding.deriveTransparentAddressFromSecretKey(tsk, networkType: networkType) else {
-                throw KeyDerivationErrors.unableToDerive
-            }
-            return tAddr
-        } catch {
-            throw KeyDerivationErrors.derivationError(underlyingError: error)
-        }
+}
+
+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
     }
 }
 
-private struct ConcreteUnifiedAddress: UnifiedAddress {
-    var tAddress: TransparentAddress
-    var zAddress: SaplingShieldedAddress
+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

@@ -15,102 +15,52 @@ public enum TransactionEncoderError: Error {
     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).
-    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
-    */
+    /// 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: String,
-        zatoshi: Int,
+        spendingKey: UnifiedSpendingKey,
+        zatoshi: Zatoshi,
         to address: String,
-        memo: String?,
+        memoBytes: MemoBytes?,
         from accountIndex: Int
-    ) throws -> EncodedTransaction
+    ) async throws -> ZcashTransaction.Overview
     
-    /**
-    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
-    */
+    /// 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: String,
-        tSecretKey: String,
-        memo: String?,
+        spendingKey: UnifiedSpendingKey,
+        shieldingThreshold: Zatoshi,
+        memoBytes: MemoBytes?,
         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
+    ) 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()
 }