zec
/
ZcashLightClientKit
mirror of https://github.com/zcash/ZcashLightClientKit.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #1517 from LukasKorba/import-ufvk-ffi-preview 

Multi-account and PCZT support
This commit is contained in:
Jack Grigg 2025-01-09 19:49:01 +00:00 committed by GitHub
parent 2b3ff26b45 3bea79c45a
commit f7029ede72
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
61 changed files with 1926 additions and 1413 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/swift.yml vendored
View File

@ -17,7 +17,7 @@ jobs:
permissions:
contents: read
runs-on: macos-13
runs-on: macos-14
steps:
- uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846

11
CHANGELOG.md
View File

@ -9,10 +9,21 @@ and this library adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
## Added
- `DerivationTool.deriveArbitraryWalletKey`
- `DerivationTool.deriveArbitraryAccountKey`
- `DerivationTool.deriveUnifiedAddressFrom(ufvk)`
- `SDKSynchronizer.listAccounts` Returns a list of the accounts in the wallet.
- `SDKSynchronizer.importAccount` Imports a new account for unified full viewing key.
- `SDKSynchronizer.createPCZTFromProposal` Creates a partially-created (unsigned without proofs) transaction from the given proposal.
- `SDKSynchronizer.addProofsToPCZT` Adds proofs to the given PCZT
- `SDKSynchronizer.createTransactionFromPCZT` Takes a PCZT that has been separately proven and signed, finalizes it, and stores it in the wallet. Internally, this logic also submits and checks the newly stored and encoded transaction.
## Changed
- `zcashlc_propose_transfer`, `zcashlc_propose_transfer_from_uri` and `zcashlc_propose_shielding` no longer accpt a `use_zip317_fees` parameter; ZIP 317 standard fees are now always used and are not configurable.
- The SDK no longer assumes a default account. All business logic with instances of Zip32AccountIndex(<index>) has been refactored.
- `SDKSynchronizer.getAccountBalance -> AccountBalance?` into `SDKSynchronizer.getAccountsBalances -> [AccountUUID: AccountBalance]`
## Removed
- `SDKSynchronizer.sendToAddress`, deprecated in 2.1
- `SDKSynchronizer.shieldFunds`, deprecated in 2.1
## Checkpoints

4
Example/ZcashLightClientSample/ZcashLightClientSample.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
View File

@ -176,8 +176,8 @@
"kind" : "remoteSourceControl",
"location" : "https://github.com/Electric-Coin-Company/zcash-light-client-ffi",
"state" : {
"revision" : "31a97a1478bc0354abdf208722b670f7fd3d9f8c",
"version" : "0.11.0"
"revision" : "11b0db058288b12ada9c5a95ed56f17f82d2868f",
"version" : "0.12.0"
}
}
],

6
Example/ZcashLightClientSample/ZcashLightClientSample/Get Address/GetAddressViewController.swift
View File

@ -19,7 +19,11 @@ class GetAddressViewController: UIViewController {
let synchronizer = SDKSynchronizer.shared
Task { @MainActor in
guard let uAddress = try? await synchronizer.getUnifiedAddress(accountIndex: Zip32AccountIndex(0)) else {
guard let account = try? await synchronizer.listAccounts().first else {
return
}
guard let uAddress = try? await synchronizer.getUnifiedAddress(accountUUID: account.id) else {
unifiedAddressLabel.text = "could not derive UA"
tAddressLabel.text = "could not derive tAddress"
saplingAddress.text = "could not derive zAddress"

10
Example/ZcashLightClientSample/ZcashLightClientSample/Get Balance/GetBalanceViewController.swift
View File

@ -19,17 +19,17 @@ class GetBalanceViewController: UIViewController {
var accountBalance: AccountBalance?
var rate: FiatCurrencyResult?
let accountIndex = Zip32AccountIndex(0)
override func viewDidLoad() {
super.viewDidLoad()
let synchronizer = AppDelegate.shared.sharedSynchronizer
self.title = "Account 0 Balance"
Task { @MainActor [weak self] in
guard let accountIndex = self?.accountIndex else { return }
self?.accountBalance = try? await synchronizer.getAccountsBalances()[accountIndex]
guard let account = try? await synchronizer.listAccounts().first else {
return
}
self?.accountBalance = try? await synchronizer.getAccountsBalances()[account.id]
self?.updateLabels()
}

32
Example/ZcashLightClientSample/ZcashLightClientSample/Get UTXOs/GetUTXOsViewController.swift
View File

@ -26,41 +26,23 @@ class GetUTXOsViewController: UIViewController {
func updateUI() {
let synchronizer = SDKSynchronizer.shared
Task { @MainActor in
let tAddress = (try? await synchronizer.getTransparentAddress(accountIndex: accountIndex))?.stringEncoded ?? "no t-address found"
guard let account = try? await synchronizer.listAccounts().first else {
return
}
let tAddress = (try? await synchronizer.getTransparentAddress(accountUUID: account.id))?.stringEncoded ?? "no t-address found"
self.transparentAddressLabel.text = tAddress
// swiftlint:disable:next force_try
let balance = try! await AppDelegate.shared.sharedSynchronizer.getAccountsBalances()[accountIndex]?.unshielded ?? .zero
let balance = try! await AppDelegate.shared.sharedSynchronizer.getAccountsBalances()[account.id]?.unshielded ?? .zero
self.totalBalanceLabel.text = NumberFormatter.zcashNumberFormatter.string(from: NSNumber(value: balance.amount))
self.verifiedBalanceLabel.text = NumberFormatter.zcashNumberFormatter.string(from: NSNumber(value: balance.amount))
}
}
@IBAction func shieldFunds(_ sender: Any) {
do {
let derivationTool = DerivationTool(networkType: kZcashNetwork.networkType)
let usk = try derivationTool.deriveUnifiedSpendingKey(seed: DemoAppConfig.defaultSeed, accountIndex: accountIndex)
KRProgressHUD.showMessage("🛡 Shielding 🛡")
Task { @MainActor in
let transaction = try await AppDelegate.shared.sharedSynchronizer.shieldFunds(
spendingKey: usk,
memo: try Memo(string: "shielding is fun!"),
shieldingThreshold: Zatoshi(10000)
)
KRProgressHUD.dismiss()
self.messageLabel.text = "funds shielded \(transaction)"
}
} catch {
self.messageLabel.text = "Shielding failed \(error)"
}
}
}
extension GetUTXOsViewController: UITextFieldDelegate {

50
Example/ZcashLightClientSample/ZcashLightClientSample/Send/SendViewController.swift
View File

@ -25,8 +25,6 @@ class SendViewController: UIViewController {
@IBOutlet weak var charactersLeftLabel: UILabel!
let characterLimit: Int = 512
let accountIndex = Zip32AccountIndex(0)
var wallet = Initializer.shared
// swiftlint:disable:next implicitly_unwrapped_optional
@ -47,7 +45,9 @@ class SendViewController: UIViewController {
closureSynchronizer.prepare(
with: DemoAppConfig.defaultSeed,
walletBirthday: DemoAppConfig.defaultBirthdayHeight,
for: .existingWallet
for: .existingWallet,
name: "",
keySource: nil
) { result in
loggerProxy.debug("Prepare result: \(result)")
}
@ -104,12 +104,17 @@ class SendViewController: UIViewController {
}
func updateBalance() async {
balanceLabel.text = format(
balance: (try? await synchronizer.getAccountsBalances()[accountIndex])?.saplingBalance.total() ?? .zero
)
verifiedBalanceLabel.text = format(
balance: (try? await synchronizer.getAccountsBalances()[accountIndex])?.saplingBalance.spendableValue ?? .zero
)
Task { @MainActor in
guard let account = try? await synchronizer.listAccounts().first else {
return
}
balanceLabel.text = format(
balance: (try? await synchronizer.getAccountsBalances()[account.id])?.saplingBalance.total() ?? .zero
)
verifiedBalanceLabel.text = format(
balance: (try? await synchronizer.getAccountsBalances()[account.id])?.saplingBalance.spendableValue ?? .zero
)
}
}
func format(balance: Zatoshi = Zatoshi()) -> String {
@ -122,8 +127,12 @@ class SendViewController: UIViewController {
func maxFundsOn() {
Task { @MainActor in
guard let account = try? await synchronizer.listAccounts().first else {
return
}
let fee = Zatoshi(10000)
let max: Zatoshi = ((try? await synchronizer.getAccountsBalances()[accountIndex])?.saplingBalance.spendableValue ?? .zero) - fee
let max: Zatoshi = ((try? await synchronizer.getAccountsBalances()[account.id])?.saplingBalance.spendableValue ?? .zero) - fee
amountTextField.text = format(balance: max)
amountTextField.isEnabled = false
}
@ -145,12 +154,18 @@ class SendViewController: UIViewController {
}
func isBalanceValid() async -> Bool {
let balance = (try? await synchronizer.getAccountsBalances()[accountIndex])?.saplingBalance.spendableValue ?? .zero
guard let account = try? await synchronizer.listAccounts().first else {
return false
}
let balance = (try? await synchronizer.getAccountsBalances()[account.id])?.saplingBalance.spendableValue ?? .zero
return balance > .zero
}
func isAmountValid() async -> Bool {
let balance = (try? await synchronizer.getAccountsBalances()[accountIndex])?.saplingBalance.spendableValue ?? .zero
guard let account = try? await synchronizer.listAccounts().first else {
return false
}
let balance = (try? await synchronizer.getAccountsBalances()[account.id])?.saplingBalance.spendableValue ?? .zero
guard
let value = amountTextField.text,
let amount = NumberFormatter.zcashNumberFormatter.number(from: value).flatMap({ Zatoshi($0.int64Value) }),
@ -229,7 +244,7 @@ class SendViewController: UIViewController {
}
let derivationTool = DerivationTool(networkType: kZcashNetwork.networkType)
guard let spendingKey = try? derivationTool.deriveUnifiedSpendingKey(seed: DemoAppConfig.defaultSeed, accountIndex: accountIndex) else {
guard let spendingKey = try? derivationTool.deriveUnifiedSpendingKey(seed: DemoAppConfig.defaultSeed, accountIndex: Zip32AccountIndex(0)) else {
loggerProxy.error("NO SPENDING KEY")
return
}
@ -237,15 +252,6 @@ class SendViewController: UIViewController {
KRProgressHUD.show()
do {
let pendingTransaction = try await synchronizer.sendToAddress(
spendingKey: spendingKey,
zatoshi: zec,
// swiftlint:disable:next force_try
toAddress: try! Recipient(recipient, network: kZcashNetwork.networkType),
// swiftlint:disable:next force_try
memo: try! self.memoField.text.asMemo()
)
loggerProxy.info("transaction created: \(pendingTransaction)")
KRProgressHUD.dismiss()
} catch {
loggerProxy.error("SEND FAILED: \(error)")

4
Example/ZcashLightClientSample/ZcashLightClientSample/Sync Blocks/SyncBlocksListViewController.swift
View File

@ -70,7 +70,9 @@ class SyncBlocksListViewController: UIViewController {
_ = try! await synchronizer.prepare(
with: synchronizerData.seed,
walletBirthday: synchronizerData.birthday,
for: .existingWallet
for: .existingWallet,
name: "",
keySource: nil
)
}

4
Example/ZcashLightClientSample/ZcashLightClientSample/Sync Blocks/SyncBlocksViewController.swift
View File

@ -102,7 +102,9 @@ class SyncBlocksViewController: UIViewController {
_ = try await synchronizer.prepare(
with: DemoAppConfig.defaultSeed,
walletBirthday: DemoAppConfig.defaultBirthdayHeight,
for: .existingWallet
for: .existingWallet,
name: "",
keySource: nil
)
} catch {
loggerProxy.error(error.toZcashError().message)

2
Package.swift
View File

@ -16,7 +16,7 @@ let package = Package(
dependencies: [
.package(url: "https://github.com/grpc/grpc-swift.git", from: "1.24.2"),
.package(url: "https://github.com/stephencelis/SQLite.swift.git", from: "0.15.3"),
.package(url: "https://github.com/Electric-Coin-Company/zcash-light-client-ffi", exact: "0.11.0")
.package(url: "https://github.com/Electric-Coin-Company/zcash-light-client-ffi", exact: "0.12.0")
],
targets: [
.target(

14
Sources/ZcashLightClientKit/Account/Account.swift
View File

@ -14,7 +14,7 @@ public struct Zip32AccountIndex: Equatable, Codable, Hashable {
/// - Parameter index: the ZIP 32 account index, which must be less than ``1<<31``.
public init(_ index: UInt32) {
guard index < (1<<31) else {
guard index < (1 << 31) else {
fatalError("Account index must be less than 1<<31. Input value is \(index).")
}
@ -34,3 +34,15 @@ public struct AccountId: Equatable, Codable, Hashable {
self.id = id
}
}
public struct AccountUUID: Equatable, Codable, Hashable, Identifiable {
public let id: [UInt8]
init(id: [UInt8]) {
guard id.count == 16 else {
fatalError("Account UUID must be 16 bytes long. Input value is \(id).")
}
self.id = id
}
}

12
Sources/ZcashLightClientKit/Block/CompactBlockProcessor.swift
View File

@ -837,16 +837,16 @@ extension CompactBlockProcessor {
}
extension CompactBlockProcessor {
func getUnifiedAddress(accountIndex: Zip32AccountIndex) async throws -> UnifiedAddress {
try await rustBackend.getCurrentAddress(accountIndex: accountIndex)
func getUnifiedAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress {
try await rustBackend.getCurrentAddress(accountUUID: accountUUID)
}
func getSaplingAddress(accountIndex: Zip32AccountIndex) async throws -> SaplingAddress {
try await getUnifiedAddress(accountIndex: accountIndex).saplingReceiver()
func getSaplingAddress(accountUUID: AccountUUID) async throws -> SaplingAddress {
try await getUnifiedAddress(accountUUID: accountUUID).saplingReceiver()
}
func getTransparentAddress(accountIndex: Zip32AccountIndex) async throws -> TransparentAddress {
try await getUnifiedAddress(accountIndex: accountIndex).transparentReceiver()
func getTransparentAddress(accountUUID: AccountUUID) async throws -> TransparentAddress {
try await getUnifiedAddress(accountUUID: accountUUID).transparentReceiver()
}
}

4
Sources/ZcashLightClientKit/Block/FetchUnspentTxOutputs/UTXOFetcher.swift
View File

@ -39,8 +39,8 @@ extension UTXOFetcherImpl: UTXOFetcher {
let accounts = try await rustBackend.listAccounts()
var tAddresses: [TransparentAddress] = []
for accountIndex in accounts {
tAddresses += try await rustBackend.listTransparentReceivers(accountIndex: accountIndex)
for account in accounts {
tAddresses += try await rustBackend.listTransparentReceivers(accountUUID: account.id)
}
var utxos: [UnspentTransactionOutputEntity] = []

6
Sources/ZcashLightClientKit/Block/SaplingParameters/SaplingParametersHandler.swift
View File

@ -35,16 +35,14 @@ extension SaplingParametersHandlerImpl: SaplingParametersHandler {
let accountBalances = try await rustBackend.getWalletSummary()?.accountBalances
for account in accounts {
let zip32AccountIndex = Zip32AccountIndex(account.index)
let totalSaplingBalance = accountBalances?[zip32AccountIndex]?.saplingBalance.total().amount ?? 0
let totalSaplingBalance = accountBalances?[account.id]?.saplingBalance.total().amount ?? 0
if totalSaplingBalance > 0 {
totalSaplingBalanceTrigger = true
break
}
let totalTransparentBalance = try await rustBackend.getTransparentBalance(accountIndex: zip32AccountIndex)
let totalTransparentBalance = try await rustBackend.getTransparentBalance(accountUUID: account.id)
if totalTransparentBalance > 0 {
totalTransparentBalanceTrigger = true

59
Sources/ZcashLightClientKit/ClosureSynchronizer.swift
View File

@ -26,19 +26,21 @@ public protocol ClosureSynchronizer {
with seed: [UInt8]?,
walletBirthday: BlockHeight,
for walletMode: WalletInitMode,
name: String,
keySource: String?,
completion: @escaping (Result<Initializer.InitializationResult, Error>) -> Void
)
func start(retry: Bool, completion: @escaping (Error?) -> Void)
func stop()
func getSaplingAddress(accountIndex: Zip32AccountIndex, completion: @escaping (Result<SaplingAddress, Error>) -> Void)
func getUnifiedAddress(accountIndex: Zip32AccountIndex, completion: @escaping (Result<UnifiedAddress, Error>) -> Void)
func getTransparentAddress(accountIndex: Zip32AccountIndex, completion: @escaping (Result<TransparentAddress, Error>) -> Void)
func getSaplingAddress(accountUUID: AccountUUID, completion: @escaping (Result<SaplingAddress, Error>) -> Void)
func getUnifiedAddress(accountUUID: AccountUUID, completion: @escaping (Result<UnifiedAddress, Error>) -> Void)
func getTransparentAddress(accountUUID: AccountUUID, completion: @escaping (Result<TransparentAddress, Error>) -> Void)
/// Creates a proposal for transferring funds to the given recipient.
///
/// - Parameter accountIndex: the ZIP 32 index of the account from which to transfer funds.
/// - Parameter accountUUID: the account from which to transfer funds.
/// - Parameter recipient: the recipient's address.
/// - Parameter amount: the amount to send in Zatoshi.
/// - Parameter memo: an optional memo to include as part of the proposal's transactions. Use `nil` when sending to transparent receivers otherwise the function will throw an error.
@ -46,7 +48,7 @@ public protocol ClosureSynchronizer {
/// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
/// `SynchronizerErrors.notPrepared`.
func proposeTransfer(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
recipient: Recipient,
amount: Zatoshi,
memo: Memo?,
@ -55,7 +57,7 @@ public protocol ClosureSynchronizer {
/// Creates a proposal for shielding any transparent funds received by the given account.
///
/// - Parameter accountIndex: the ZIP 32 index of the account from which to shield funds.
/// - Parameter accountUUID: the account from which to shield funds.
/// - Parameter shieldingThreshold: the minimum transparent balance required before a proposal will be created.
/// - Parameter memo: an optional memo to include as part of the proposal's transactions.
/// - Parameter transparentReceiver: a specific transparent receiver within the account
@ -69,7 +71,7 @@ public protocol ClosureSynchronizer {
/// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
/// `SynchronizerErrors.notPrepared`.
func proposeShielding(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
shieldingThreshold: Zatoshi,
memo: Memo,
transparentReceiver: TransparentAddress?,
@ -93,22 +95,35 @@ public protocol ClosureSynchronizer {
completion: @escaping (Result<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>) -> Void
)
@available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
func sendToAddress(
spendingKey: UnifiedSpendingKey,
zatoshi: Zatoshi,
toAddress: Recipient,
memo: Memo?,
completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
func createPCZTFromProposal(
accountUUID: AccountUUID,
proposal: Proposal,
completion: @escaping (Result<Pczt, Error>) -> Void
)
func addProofsToPCZT(
pczt: Pczt,
completion: @escaping (Result<Pczt, Error>) -> Void
)
func createTransactionFromPCZT(
pcztWithProofs: Pczt,
pcztWithSigs: Pczt,
completion: @escaping (Result<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>) -> Void
)
@available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
func shieldFunds(
spendingKey: UnifiedSpendingKey,
memo: Memo,
shieldingThreshold: Zatoshi,
completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
)
func listAccounts(completion: @escaping (Result<[Account], Error>) -> Void)
// swiftlint:disable:next function_parameter_count
func importAccount(
ufvk: String,
seedFingerprint: [UInt8]?,
zip32AccountIndex: Zip32AccountIndex?,
purpose: AccountPurpose,
name: String,
keySource: String?,
completion: @escaping (Result<AccountUUID, Error>) -> Void
) async throws
func clearedTransactions(completion: @escaping ([ZcashTransaction.Overview]) -> Void)
func sentTranscations(completion: @escaping ([ZcashTransaction.Overview]) -> Void)
@ -127,7 +142,7 @@ public protocol ClosureSynchronizer {
func refreshUTXOs(address: TransparentAddress, from height: BlockHeight, completion: @escaping (Result<RefreshedUTXOs, Error>) -> Void)
func getAccountsBalances(completion: @escaping (Result<[Zip32AccountIndex: AccountBalance], Error>) -> Void)
func getAccountsBalances(_ completion: @escaping (Result<[AccountUUID: AccountBalance], Error>) -> Void)
func refreshExchangeRateUSD()

63
Sources/ZcashLightClientKit/CombineSynchronizer.swift
View File

@ -25,19 +25,21 @@ public protocol CombineSynchronizer {
func prepare(
with seed: [UInt8]?,
walletBirthday: BlockHeight,
for walletMode: WalletInitMode
for walletMode: WalletInitMode,
name: String,
keySource: String?
) -> SinglePublisher<Initializer.InitializationResult, Error>
func start(retry: Bool) -> CompletablePublisher<Error>
func stop()
func getSaplingAddress(accountIndex: Zip32AccountIndex) -> SinglePublisher<SaplingAddress, Error>
func getUnifiedAddress(accountIndex: Zip32AccountIndex) -> SinglePublisher<UnifiedAddress, Error>
func getTransparentAddress(accountIndex: Zip32AccountIndex) -> SinglePublisher<TransparentAddress, Error>
func getSaplingAddress(accountUUID: AccountUUID) -> SinglePublisher<SaplingAddress, Error>
func getUnifiedAddress(accountUUID: AccountUUID) -> SinglePublisher<UnifiedAddress, Error>
func getTransparentAddress(accountUUID: AccountUUID) -> SinglePublisher<TransparentAddress, Error>
/// Creates a proposal for transferring funds to the given recipient.
///
/// - Parameter accountIndex: the ZIP 32 index of the account from which to transfer funds.
/// - Parameter accountUUID: the account from which to transfer funds.
/// - Parameter recipient: the recipient's address.
/// - Parameter amount: the amount to send in Zatoshi.
/// - Parameter memo: an optional memo to include as part of the proposal's transactions. Use `nil` when sending to transparent receivers otherwise the function will throw an error.
@ -45,7 +47,7 @@ public protocol CombineSynchronizer {
/// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
/// `SynchronizerErrors.notPrepared`.
func proposeTransfer(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
recipient: Recipient,
amount: Zatoshi,
memo: Memo?
@ -53,7 +55,7 @@ public protocol CombineSynchronizer {
/// Creates a proposal for shielding any transparent funds received by the given account.
///
/// - Parameter accountIndex: the ZIP 32 index of the account from which to shield funds.
/// - Parameter accountUUID: the account from which to shield funds.
/// - Parameter shieldingThreshold: the minimum transparent balance required before a proposal will be created.
/// - Parameter memo: an optional memo to include as part of the proposal's transactions.
/// - Parameter transparentReceiver: a specific transparent receiver within the account
@ -67,7 +69,7 @@ public protocol CombineSynchronizer {
/// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
/// `SynchronizerErrors.notPrepared`.
func proposeShielding(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
shieldingThreshold: Zatoshi,
memo: Memo,
transparentReceiver: TransparentAddress?
@ -89,30 +91,37 @@ public protocol CombineSynchronizer {
spendingKey: UnifiedSpendingKey
) -> SinglePublisher<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>
@available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
func sendToAddress(
spendingKey: UnifiedSpendingKey,
zatoshi: Zatoshi,
toAddress: Recipient,
memo: Memo?
) -> SinglePublisher<ZcashTransaction.Overview, Error>
@available(
*,
deprecated,
message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients. use `proposeShielding:` instead"
)
func shieldFunds(
spendingKey: UnifiedSpendingKey,
memo: Memo,
shieldingThreshold: Zatoshi
) -> SinglePublisher<ZcashTransaction.Overview, Error>
func createPCZTFromProposal(
accountUUID: AccountUUID,
proposal: Proposal
) -> SinglePublisher<Pczt, Error>
func addProofsToPCZT(
pczt: Pczt
) -> SinglePublisher<Pczt, Error>
func createTransactionFromPCZT(
pcztWithProofs: Pczt,
pcztWithSigs: Pczt
) -> SinglePublisher<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>
func proposefulfillingPaymentURI(
_ uri: String,
accountIndex: Zip32AccountIndex
accountUUID: AccountUUID
) -> SinglePublisher<Proposal, Error>
func listAccounts() -> SinglePublisher<[Account], Error>
// swiftlint:disable:next function_parameter_count
func importAccount(
ufvk: String,
seedFingerprint: [UInt8]?,
zip32AccountIndex: Zip32AccountIndex?,
purpose: AccountPurpose,
name: String,
keySource: String?
) async throws -> SinglePublisher<AccountUUID, Error>
var allTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
var sentTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }
var receivedTransactions: SinglePublisher<[ZcashTransaction.Overview], Never> { get }

8
Sources/ZcashLightClientKit/Constants/ZcashSDK.swift
View File

@ -11,7 +11,7 @@ public protocol ZcashNetwork {
var constants: NetworkConstants.Type { get }
}
public enum NetworkType {
public enum NetworkType: Equatable, Codable, Hashable {
case mainnet
case testnet
@ -219,3 +219,9 @@ public enum ZcashSDKTestnetConstants: NetworkConstants {
public static let defaultDbNamePrefix = "ZcashSdk_testnet_"
}
/// Used when importing an account `importAccount(..., purpose: AccountPurpose)`
public enum AccountPurpose: UInt32, Equatable {
case spending = 0
case viewOnly
}

10
Sources/ZcashLightClientKit/Entity/Pczt.swift Normal file
View File

@ -0,0 +1,10 @@
//
// Pczt.swift
// ZcashLightClientKit
//
// Created by Lukáš Korba on 13.12.2024.
//
import Foundation
public typealias Pczt = Data

16
Sources/ZcashLightClientKit/Entity/TransactionEntity.swift
View File

@ -44,7 +44,7 @@ public enum ZcashTransaction {
}
}
public let accountId: AccountId
public let accountUUID: AccountUUID
public let blockTime: TimeInterval?
public let expiryHeight: BlockHeight?
public let fee: Zatoshi?
@ -85,7 +85,7 @@ public enum ZcashTransaction {
public let rawID: Data
public let pool: Pool
public let index: Int
public let fromAccount: AccountId?
public let fromAccount: AccountUUID?
public let recipient: TransactionRecipient
public let value: Zatoshi
public let isChange: Bool
@ -105,8 +105,8 @@ extension ZcashTransaction.Output {
static let rawID = SQLite.Expression<Blob>("txid")
static let pool = SQLite.Expression<Int>("output_pool")
static let index = SQLite.Expression<Int>("output_index")
static let toAccount = SQLite.Expression<Int?>("to_account_id")
static let fromAccount = SQLite.Expression<Int?>("from_account_id")
static let toAccount = SQLite.Expression<Blob?>("to_account_uuid")
static let fromAccount = SQLite.Expression<Blob?>("from_account_uuid")
static let toAddress = SQLite.Expression<String?>("to_address")
static let value = SQLite.Expression<Int64>("value")
static let isChange = SQLite.Expression<Bool>("is_change")
@ -119,7 +119,7 @@ extension ZcashTransaction.Output {
pool = .init(rawValue: try row.get(Column.pool))
index = try row.get(Column.index)
if let accountId = try row.get(Column.fromAccount) {
fromAccount = AccountId(accountId)
fromAccount = AccountUUID(id: [UInt8](Data(blob: accountId)))
} else {
fromAccount = nil
}
@ -132,7 +132,7 @@ extension ZcashTransaction.Output {
{
recipient = TransactionRecipient.address(try Recipient(outputRecipient, network: metadata.networkType))
} else if let toAccount = try row.get(Column.toAccount) {
recipient = .internalAccount(UInt32(toAccount))
recipient = .internalAccount(AccountUUID(id: [UInt8](Data(blob: toAccount))))
} else {
throw ZcashError.zcashTransactionOutputInconsistentRecipient
}
@ -150,7 +150,7 @@ extension ZcashTransaction.Output {
extension ZcashTransaction.Overview {
enum Column {
static let accountId = SQLite.Expression<Int>("account_id")
static let accountUUID = SQLite.Expression<Blob>("account_uuid")
static let minedHeight = SQLite.Expression<BlockHeight?>("mined_height")
static let index = SQLite.Expression<Int?>("tx_index")
static let rawID = SQLite.Expression<Blob>("txid")
@ -169,7 +169,7 @@ extension ZcashTransaction.Overview {
init(row: Row) throws {
do {
self.accountId = AccountId(try row.get(Column.accountId))
self.accountUUID = AccountUUID(id: [UInt8](Data(blob: try row.get(Column.accountUUID))))
self.expiryHeight = try row.get(Column.expiryHeight)
self.index = try row.get(Column.index)
self.hasChange = try row.get(Column.hasChange)

46
Sources/ZcashLightClientKit/Error/ZcashError.swift
View File

@ -151,7 +151,7 @@ public enum ZcashError: Equatable, Error {
/// - `account` is account passed to ZcashRustBackend.getTransparentBalance.
/// - `rustError` contains error generated by the rust layer.
/// ZRUST0011
case rustGetTransparentBalance(_ account: Int, _ rustError: String)
case rustGetTransparentBalance(_ accountUUID: AccountUUID, _ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.getVerifiedBalance
/// - `account` is account passed to ZcashRustBackend.getVerifiedBalance.
/// - `rustError` contains error generated by the rust layer.
@ -165,7 +165,7 @@ public enum ZcashError: Equatable, Error {
/// - `account` is account passed to ZcashRustBackend.getVerifiedTransparentBalance.
/// - `rustError` contains error generated by the rust layer.
/// ZRUST0014
case rustGetVerifiedTransparentBalance(_ account: Int, _ rustError: String)
case rustGetVerifiedTransparentBalance(_ accountUUID: AccountUUID, _ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.initDataDb
/// - `rustError` contains error generated by the rust layer.
/// ZRUST0015
@ -364,6 +364,34 @@ public enum ZcashError: Equatable, Error {
/// - `rustError` contains error generated by the rust layer.
/// ZRUST0066
case rustDeriveArbitraryAccountKey(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.importAccountUfvk
/// - `rustError` contains error generated by the rust layer.
/// ZRUST0067
case rustImportAccountUfvk(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.deriveAddressFromUfvk
/// - `rustError` contains error generated by the rust layer.
/// ZRUST0068
case rustDeriveAddressFromUfvk(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.createPCZTFromProposal
/// - `rustError` contains error generated by the rust layer.
/// ZRUST0069
case rustCreatePCZTFromProposal(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.addProofsToPCZT
/// - `rustError` contains error generated by the rust layer.
/// ZRUST0070
case rustAddProofsToPCZT(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.extractAndStoreTxFromPCZT
/// - `rustError` contains error generated by the rust layer.
/// ZRUST0071
case rustExtractAndStoreTxFromPCZT(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.getAccount
/// - `rustError` contains error generated by the rust layer.
/// ZRUST0072
case rustUUIDAccountNotFound(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.extractAndStoreTxFromPCZT
/// - `rustError` contains error generated by the rust layer.
/// ZRUST0073
case rustTxidPtrIncorrectLength(_ rustError: String)
/// SQLite query failed when fetching all accounts from the database.
/// - `sqliteError` is error produced by SQLite library.
/// ZADAO0001
@ -732,6 +760,13 @@ public enum ZcashError: Equatable, Error {
case .rustTransactionDataRequests: return "Error from rust layer when calling ZcashRustBackend.transactionDataRequests"
case .rustDeriveArbitraryWalletKey: return "Error from rust layer when calling ZcashRustBackend.deriveArbitraryWalletKey"
case .rustDeriveArbitraryAccountKey: return "Error from rust layer when calling ZcashRustBackend.deriveArbitraryAccountKey"
case .rustImportAccountUfvk: return "Error from rust layer when calling ZcashRustBackend.importAccountUfvk"
case .rustDeriveAddressFromUfvk: return "Error from rust layer when calling ZcashRustBackend.deriveAddressFromUfvk"
case .rustCreatePCZTFromProposal: return "Error from rust layer when calling ZcashRustBackend.createPCZTFromProposal"
case .rustAddProofsToPCZT: return "Error from rust layer when calling ZcashRustBackend.addProofsToPCZT"
case .rustExtractAndStoreTxFromPCZT: return "Error from rust layer when calling ZcashRustBackend.extractAndStoreTxFromPCZT"
case .rustUUIDAccountNotFound: return "Error from rust layer when calling ZcashRustBackend.getAccount"
case .rustTxidPtrIncorrectLength: return "Error from rust layer when calling ZcashRustBackend.extractAndStoreTxFromPCZT"
case .accountDAOGetAll: return "SQLite query failed when fetching all accounts from the database."
case .accountDAOGetAllCantDecode: return "Fetched accounts from SQLite but can't decode them."
case .accountDAOFindBy: return "SQLite query failed when seaching for accounts in the database."
@ -917,6 +952,13 @@ public enum ZcashError: Equatable, Error {
case .rustTransactionDataRequests: return .rustTransactionDataRequests
case .rustDeriveArbitraryWalletKey: return .rustDeriveArbitraryWalletKey
case .rustDeriveArbitraryAccountKey: return .rustDeriveArbitraryAccountKey
case .rustImportAccountUfvk: return .rustImportAccountUfvk
case .rustDeriveAddressFromUfvk: return .rustDeriveAddressFromUfvk
case .rustCreatePCZTFromProposal: return .rustCreatePCZTFromProposal
case .rustAddProofsToPCZT: return .rustAddProofsToPCZT
case .rustExtractAndStoreTxFromPCZT: return .rustExtractAndStoreTxFromPCZT
case .rustUUIDAccountNotFound: return .rustUUIDAccountNotFound
case .rustTxidPtrIncorrectLength: return .rustTxidPtrIncorrectLength
case .accountDAOGetAll: return .accountDAOGetAll
case .accountDAOGetAllCantDecode: return .accountDAOGetAllCantDecode
case .accountDAOFindBy: return .accountDAOFindBy

14
Sources/ZcashLightClientKit/Error/ZcashErrorCode.swift
View File

@ -195,6 +195,20 @@ public enum ZcashErrorCode: String {
case rustDeriveArbitraryWalletKey = "ZRUST0065"
/// Error from rust layer when calling ZcashRustBackend.deriveArbitraryAccountKey
case rustDeriveArbitraryAccountKey = "ZRUST0066"
/// Error from rust layer when calling ZcashRustBackend.importAccountUfvk
case rustImportAccountUfvk = "ZRUST0067"
/// Error from rust layer when calling ZcashRustBackend.deriveAddressFromUfvk
case rustDeriveAddressFromUfvk = "ZRUST0068"
/// Error from rust layer when calling ZcashRustBackend.createPCZTFromProposal
case rustCreatePCZTFromProposal = "ZRUST0069"
/// Error from rust layer when calling ZcashRustBackend.addProofsToPCZT
case rustAddProofsToPCZT = "ZRUST0070"
/// Error from rust layer when calling ZcashRustBackend.extractAndStoreTxFromPCZT
case rustExtractAndStoreTxFromPCZT = "ZRUST0071"
/// Error from rust layer when calling ZcashRustBackend.getAccount
case rustUUIDAccountNotFound = "ZRUST0072"
/// Error from rust layer when calling ZcashRustBackend.extractAndStoreTxFromPCZT
case rustTxidPtrIncorrectLength = "ZRUST0073"
/// SQLite query failed when fetching all accounts from the database.
case accountDAOGetAll = "ZADAO0001"
/// Fetched accounts from SQLite but can't decode them.

32
Sources/ZcashLightClientKit/Error/ZcashErrorCodeDefinition.swift
View File

@ -182,7 +182,7 @@ enum ZcashErrorDefinition {
/// - `account` is account passed to ZcashRustBackend.getTransparentBalance.
/// - `rustError` contains error generated by the rust layer.
// sourcery: code="ZRUST0011"
case rustGetTransparentBalance(_ account: Int, _ rustError: String)
case rustGetTransparentBalance(_ accountUUID: AccountUUID, _ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.getVerifiedBalance
/// - `account` is account passed to ZcashRustBackend.getVerifiedBalance.
/// - `rustError` contains error generated by the rust layer.
@ -196,7 +196,7 @@ enum ZcashErrorDefinition {
/// - `account` is account passed to ZcashRustBackend.getVerifiedTransparentBalance.
/// - `rustError` contains error generated by the rust layer.
// sourcery: code="ZRUST0014"
case rustGetVerifiedTransparentBalance(_ account: Int, _ rustError: String)
case rustGetVerifiedTransparentBalance(_ accountUUID: AccountUUID, _ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.initDataDb
/// - `rustError` contains error generated by the rust layer.
// sourcery: code="ZRUST0015"
@ -386,6 +386,34 @@ enum ZcashErrorDefinition {
/// - `rustError` contains error generated by the rust layer.
// sourcery: code="ZRUST0066"
case rustDeriveArbitraryAccountKey(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.importAccountUfvk
/// - `rustError` contains error generated by the rust layer.
// sourcery: code="ZRUST0067"
case rustImportAccountUfvk(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.deriveAddressFromUfvk
/// - `rustError` contains error generated by the rust layer.
// sourcery: code="ZRUST0068"
case rustDeriveAddressFromUfvk(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.createPCZTFromProposal
/// - `rustError` contains error generated by the rust layer.
// sourcery: code="ZRUST0069"
case rustCreatePCZTFromProposal(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.addProofsToPCZT
/// - `rustError` contains error generated by the rust layer.
// sourcery: code="ZRUST0070"
case rustAddProofsToPCZT(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.extractAndStoreTxFromPCZT
/// - `rustError` contains error generated by the rust layer.
// sourcery: code="ZRUST0071"
case rustExtractAndStoreTxFromPCZT(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.getAccount
/// - `rustError` contains error generated by the rust layer.
// sourcery: code="ZRUST0072"
case rustUUIDAccountNotFound(_ rustError: String)
/// Error from rust layer when calling ZcashRustBackend.extractAndStoreTxFromPCZT
/// - `rustError` contains error generated by the rust layer.
// sourcery: code="ZRUST0073"
case rustTxidPtrIncorrectLength(_ rustError: String)
// MARK: - Account DAO

12
Sources/ZcashLightClientKit/Initializer.swift
View File

@ -406,7 +406,13 @@ public class Initializer {
/// - Parameter seed: ZIP-32 Seed bytes for the wallet that will be initialized
/// - Throws: `InitializerError.dataDbInitFailed` if the creation of the dataDb fails
/// `InitializerError.accountInitFailed` if the account table can't be initialized.
func initialize(with seed: [UInt8]?, walletBirthday: BlockHeight, for walletMode: WalletInitMode) async throws -> InitializationResult {
func initialize(
with seed: [UInt8]?,
walletBirthday: BlockHeight,
for walletMode: WalletInitMode,
name: String,
keySource: String? = nil
) async throws -> InitializationResult {
try await storage.create()
if case .seedRequired = try await rustBackend.initDataDb(seed: seed) {
@ -430,7 +436,9 @@ public class Initializer {
_ = try await rustBackend.createAccount(
seed: seed,
treeState: checkpoint.treeState(),
recoverUntil: chainTip
recoverUntil: chainTip,
name: name,
keySource: keySource
)
}

2
Sources/ZcashLightClientKit/Model/WalletSummary.swift
View File

@ -49,7 +49,7 @@ struct ScanProgress: Equatable {
}
struct WalletSummary: Equatable {
let accountBalances: [Zip32AccountIndex: AccountBalance]
let accountBalances: [AccountUUID: AccountBalance]
let chainTipHeight: BlockHeight
let fullyScannedHeight: BlockHeight
let scanProgress: ScanProgress?

18
Sources/ZcashLightClientKit/Model/WalletTypes.swift
View File

@ -10,10 +10,17 @@ public protocol StringEncoded {
var stringEncoded: String { get }
}
public struct Account: Equatable, Hashable, Codable, Identifiable {
public let id: AccountUUID
public let name: String?
public let keySource: String?
public let seedFingerprint: [UInt8]?
public let hdAccountIndex: Zip32AccountIndex?
}
public struct UnifiedSpendingKey: Equatable, Undescribable {
let network: NetworkType
let bytes: [UInt8]
public let accountIndex: Zip32AccountIndex
}
/// Sapling Extended Spending Key
@ -45,23 +52,20 @@ public struct TransparentAccountPrivKey: Equatable, Undescribable {
/// A ZIP 316 Unified Full Viewing Key.
public struct UnifiedFullViewingKey: Equatable, StringEncoded, Undescribable {
let encoding: String
public let accountIndex: Zip32AccountIndex
public var stringEncoded: String { encoding }
/// Initializes a new UnifiedFullViewingKey (UFVK) from the provided string encoding
/// - Parameters:
/// - parameter encoding: String encoding of unified full viewing key
/// - parameter accountIndex: the ZIP32 account Index of the given UFVK
/// - parameter network: `NetworkType` corresponding to the encoding (Mainnet or Testnet)
/// - Throws: `unifiedFullViewingKeyInvalidInput`when the provided encoding is found to be invalid
public init(encoding: String, accountIndex: Zip32AccountIndex, network: NetworkType) throws {
public init(encoding: String, network: NetworkType) throws {
guard DerivationTool(networkType: network).isValidUnifiedFullViewingKey(encoding) else {
throw ZcashError.unifiedFullViewingKeyInvalidInput
}
self.encoding = encoding
self.accountIndex = accountIndex
}
}
@ -166,7 +170,7 @@ public struct SaplingAddress: Equatable, StringEncoded {
}
}
public struct UnifiedAddress: Equatable, StringEncoded {
public struct UnifiedAddress: Equatable, StringEncoded, Codable, Hashable {
let networkType: NetworkType
public enum ReceiverTypecodes: Hashable {
@ -247,7 +251,7 @@ public struct TexAddress: Equatable, StringEncoded, Comparable {
public enum TransactionRecipient: Equatable {
case address(Recipient)
case internalAccount(UInt32)
case internalAccount(AccountUUID)
}
/// Represents a valid recipient of Zcash

26
Sources/ZcashLightClientKit/Rust/ZcashKeyDerivationBackend.swift
View File

@ -93,11 +93,27 @@ struct ZcashKeyDerivationBackend: ZcashKeyDerivationBackendWelding {
// MARK: Address Derivation
func deriveUnifiedAddressFrom(ufvk: String) throws -> UnifiedAddress {
let ffiAddressPtr = zcashlc_derive_address_from_ufvk(
networkType.networkId,
[CChar](ufvk.utf8CString),
nil
)
guard let ffiAddressPtr else {
throw ZcashError.rustDeriveAddressFromUfvk(ZcashKeyDerivationBackend.lastErrorMessage(fallback: "`deriveAddressFromUfvk` failed with unknown error"))
}
defer { zcashlc_free_ffi_address(ffiAddressPtr) }
return ffiAddressPtr.pointee.unsafeToUnifiedAddress(networkType)
}
func deriveUnifiedSpendingKey(
from seed: [UInt8],
accountIndex: Zip32AccountIndex
) throws -> UnifiedSpendingKey {
let binaryKeyPtr = seed.withUnsafeBufferPointer { seedBufferPtr in
let boxedSlicePtr = seed.withUnsafeBufferPointer { seedBufferPtr in
return zcashlc_derive_spending_key(
seedBufferPtr.baseAddress,
UInt(seed.count),
@ -106,14 +122,14 @@ struct ZcashKeyDerivationBackend: ZcashKeyDerivationBackendWelding {
)
}
defer { zcashlc_free_binary_key(binaryKeyPtr) }
defer { zcashlc_free_boxed_slice(boxedSlicePtr) }
guard let binaryKey = binaryKeyPtr?.pointee else {
guard let boxedSlice = boxedSlicePtr?.pointee else {
throw ZcashError.rustDeriveUnifiedSpendingKey(
ZcashKeyDerivationBackend.lastErrorMessage(fallback: "`deriveUnifiedSpendingKey` failed with unknown error"))
}
return binaryKey.unsafeToUnifiedSpendingKey(network: networkType)
return boxedSlice.unsafeToUnifiedSpendingKey(network: networkType)
}
func deriveUnifiedFullViewingKey(from spendingKey: UnifiedSpendingKey) throws -> UnifiedFullViewingKey {
@ -137,7 +153,7 @@ struct ZcashKeyDerivationBackend: ZcashKeyDerivationBackendWelding {
throw ZcashError.rustDeriveUnifiedFullViewingKeyInvalidDerivedKey
}
return UnifiedFullViewingKey(validatedEncoding: derived, accountIndex: spendingKey.accountIndex)
return UnifiedFullViewingKey(validatedEncoding: derived)
}
func getSaplingReceiver(for uAddr: UnifiedAddress) throws -> SaplingAddress {

5
Sources/ZcashLightClientKit/Rust/ZcashKeyDerivationBackendWelding.swift
View File

@ -40,6 +40,11 @@ protocol ZcashKeyDerivationBackendWelding {
/// - Returns: true when the encoded string is a valid UFVK. false in any other case
func isValidUnifiedFullViewingKey(_ ufvk: String) -> Bool
/// Derives and returns a UnifiedAddress from a UnifiedFullViewingKey
/// - Parameter ufvk: UTF-8 encoded String containing a valid UFVK
/// - Returns: the corresponding default `UnifiedAddress`
func deriveUnifiedAddressFrom(ufvk: String) throws -> UnifiedAddress
/// Derives and returns a unified spending key from the given seed and ZIP 32 account index.
/// Returns the binary encoding of the spending key. The caller should manage the memory of (and store, if necessary) the returned spending key in a secure fashion.
/// - Parameter seed: a Byte Array with the seed

356
Sources/ZcashLightClientKit/Rust/ZcashRustBackend.swift
View File

@ -72,7 +72,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
}
@DBActor
func listAccounts() async throws -> [Zip32AccountIndex] {
func listAccounts() async throws -> [Account] {
let accountsPtr = zcashlc_list_accounts(
dbData.0,
dbData.1,
@ -85,18 +85,104 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
defer { zcashlc_free_accounts(accountsPtr) }
var accounts: [Zip32AccountIndex] = []
var accounts: [Account] = []
for i in (0 ..< Int(accountsPtr.pointee.len)) {
let account = accountsPtr.pointee.ptr.advanced(by: i).pointee
accounts.append(Zip32AccountIndex(account.account_index))
let accountUUIDPtr = accountsPtr.pointee.ptr.advanced(by: i).pointee
let accountUUID = AccountUUID(id: accountUUIDPtr.uuidArray)
let account = try await getAccount(for: accountUUID)
accounts.append(account)
}
return accounts
}
@DBActor
func createAccount(seed: [UInt8], treeState: TreeState, recoverUntil: UInt32?) async throws -> UnifiedSpendingKey {
func getAccount(
for accountUUID: AccountUUID
) async throws -> Account {
let accountPtr: UnsafeMutablePointer<FfiAccount>? = zcashlc_get_account(
dbData.0,
dbData.1,
networkType.networkId,
accountUUID.id
)
guard let accountPtr else {
throw ZcashError.rustImportAccountUfvk(lastErrorMessage(fallback: "`getAccount` failed with unknown error"))
}
defer { zcashlc_free_account(accountPtr) }
guard let validAccount = accountPtr.pointee.unsafeToAccount() else {
throw ZcashError.rustUUIDAccountNotFound(lastErrorMessage(fallback: "`getAccount` failed with unknown error"))
}
return validAccount
}
// swiftlint:disable:next function_parameter_count
@DBActor
func importAccount(
ufvk: String,
seedFingerprint: [UInt8]?,
zip32AccountIndex: Zip32AccountIndex?,
treeState: TreeState,
recoverUntil: UInt32?,
purpose: AccountPurpose,
name: String,
keySource: String?
) async throws -> AccountUUID {
var rUntil: Int64 = -1
if let recoverUntil {
rUntil = Int64(recoverUntil)
}
let treeStateBytes = try treeState.serializedData(partial: false).bytes
var kSource: [CChar]?
if let keySource {
kSource = [CChar](keySource.utf8CString)
}
let index: UInt32 = zip32AccountIndex?.index ?? UINT32_MAX
let uuidPtr = zcashlc_import_account_ufvk(
dbData.0,
dbData.1,
[CChar](ufvk.utf8CString),
treeStateBytes,
UInt(treeStateBytes.count),
rUntil,
networkType.networkId,
purpose.rawValue,
[CChar](name.utf8CString),
kSource,
seedFingerprint,
index
)
guard let uuidPtr else {
throw ZcashError.rustImportAccountUfvk(lastErrorMessage(fallback: "`importAccount` failed with unknown error"))
}
defer { zcashlc_free_ffi_uuid(uuidPtr) }
return uuidPtr.pointee.unsafeToAccountUUID()
}
@DBActor
func createAccount(
seed: [UInt8],
treeState: TreeState,
recoverUntil: UInt32?,
name: String,
keySource: String?
) async throws -> UnifiedSpendingKey {
var rUntil: Int64 = -1
if let recoverUntil {
@ -105,6 +191,12 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
let treeStateBytes = try treeState.serializedData(partial: false).bytes
var kSource: [CChar]?
if let keySource {
kSource = [CChar](keySource.utf8CString)
}
let ffiBinaryKeyPtr = zcashlc_create_account(
dbData.0,
dbData.1,
@ -113,7 +205,9 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
treeStateBytes,
UInt(treeStateBytes.count),
rUntil,
networkType.networkId
networkType.networkId,
[CChar](name.utf8CString),
kSource
)
guard let ffiBinaryKeyPtr else {
@ -148,7 +242,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
@DBActor
func proposeTransfer(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
to address: String,
value: Int64,
memo: MemoBytes?
@ -156,7 +250,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
let proposal = zcashlc_propose_transfer(
dbData.0,
dbData.1,
LCZip32Index(accountIndex.index),
accountUUID.id,
[CChar](address.utf8CString),
value,
memo?.bytes,
@ -170,7 +264,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
defer { zcashlc_free_boxed_slice(proposal) }
return try FfiProposal(contiguousBytes: Data(
return try FfiProposal(serializedBytes: Data(
bytes: proposal.pointee.ptr,
count: Int(proposal.pointee.len)
))
@ -179,12 +273,12 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
@DBActor
func proposeTransferFromURI(
_ uri: String,
accountIndex: Zip32AccountIndex
accountUUID: AccountUUID
) async throws -> FfiProposal {
let proposal = zcashlc_propose_transfer_from_uri(
dbData.0,
dbData.1,
LCZip32Index(accountIndex.index),
accountUUID.id,
[CChar](uri.utf8CString),
networkType.networkId,
minimumConfirmations
@ -196,11 +290,119 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
defer { zcashlc_free_boxed_slice(proposal) }
return try FfiProposal(contiguousBytes: Data(
return try FfiProposal(serializedBytes: Data(
bytes: proposal.pointee.ptr,
count: Int(proposal.pointee.len)
))
}
@DBActor
func createPCZTFromProposal(
accountUUID: AccountUUID,
proposal: FfiProposal
) async throws -> Pczt {
let proposalBytes = try proposal.serializedData(partial: false).bytes
let pcztPtr = proposalBytes.withUnsafeBufferPointer { proposalPtr in
zcashlc_create_pczt_from_proposal(
dbData.0,
dbData.1,
networkType.networkId,
proposalPtr.baseAddress,
UInt(proposalBytes.count),
accountUUID.id
)
}
guard let pcztPtr else {
throw ZcashError.rustCreatePCZTFromProposal(lastErrorMessage(fallback: "`createPCZTFromProposal` failed with unknown error"))
}
defer { zcashlc_free_boxed_slice(pcztPtr) }
return Pczt(
bytes: pcztPtr.pointee.ptr,
count: Int(pcztPtr.pointee.len)
)
}
@DBActor
func addProofsToPCZT(
pczt: Pczt
) async throws -> Pczt {
let pcztPtr: UnsafeMutablePointer<FfiBoxedSlice>? = pczt.withUnsafeBytes { buffer in
guard let bufferPtr = buffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
return nil
}
return zcashlc_add_proofs_to_pczt(
bufferPtr,
UInt(pczt.count),
spendParamsPath.0,
spendParamsPath.1,
outputParamsPath.0,
outputParamsPath.1
)
}
guard let pcztPtr else {
throw ZcashError.rustAddProofsToPCZT(lastErrorMessage(fallback: "`addProofsToPCZT` failed with unknown error"))
}
defer { zcashlc_free_boxed_slice(pcztPtr) }
return Pczt(
bytes: pcztPtr.pointee.ptr,
count: Int(pcztPtr.pointee.len)
)
}
@DBActor
func extractAndStoreTxFromPCZT(
pcztWithProofs: Pczt,
pcztWithSigs: Pczt
) async throws -> Data {
let txidPtr: UnsafeMutablePointer<FfiBoxedSlice>? = pcztWithProofs.withUnsafeBytes { pcztWithProofsBuffer in
guard let pcztWithProofsBufferPtr = pcztWithProofsBuffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
return nil
}
return pcztWithSigs.withUnsafeBytes { pcztWithSigsBuffer in
guard let pcztWithSigsBufferPtr = pcztWithSigsBuffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
return nil
}
return zcashlc_extract_and_store_from_pczt(
dbData.0,
dbData.1,
networkType.networkId,
pcztWithProofsBufferPtr,
UInt(pcztWithProofs.count),
pcztWithSigsBufferPtr,
UInt(pcztWithSigs.count),
spendParamsPath.0,
spendParamsPath.1,
outputParamsPath.0,
outputParamsPath.1
)
}
}
guard let txidPtr else {
throw ZcashError.rustExtractAndStoreTxFromPCZT(lastErrorMessage(fallback: "`extractAndStoreTxFromPCZT` failed with unknown error"))
}
guard txidPtr.pointee.len == 32 else {
throw ZcashError.rustTxidPtrIncorrectLength(lastErrorMessage(fallback: "`extractAndStoreTxFromPCZT` failed with unknown error"))
}
defer { zcashlc_free_boxed_slice(txidPtr) }
return Data(
bytes: txidPtr.pointee.ptr,
count: Int(txidPtr.pointee.len)
)
}
@DBActor
func decryptAndStoreTransaction(txBytes: [UInt8], minedHeight: UInt32?) async throws {
@ -219,11 +421,11 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
}
@DBActor
func getCurrentAddress(accountIndex: Zip32AccountIndex) async throws -> UnifiedAddress {
func getCurrentAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress {
let addressCStr = zcashlc_get_current_address(
dbData.0,
dbData.1,
LCZip32Index(accountIndex.index),
accountUUID.id,
networkType.networkId
)
@ -241,11 +443,11 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
}
@DBActor
func getNextAvailableAddress(accountIndex: Zip32AccountIndex) async throws -> UnifiedAddress {
func getNextAvailableAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress {
let addressCStr = zcashlc_get_next_available_address(
dbData.0,
dbData.1,
LCZip32Index(accountIndex.index),
accountUUID.id,
networkType.networkId
)
@ -281,18 +483,18 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
}
@DBActor
func getTransparentBalance(accountIndex: Zip32AccountIndex) async throws -> Int64 {
func getTransparentBalance(accountUUID: AccountUUID) async throws -> Int64 {
let balance = zcashlc_get_total_transparent_balance_for_account(
dbData.0,
dbData.1,
networkType.networkId,
LCZip32Index(accountIndex.index)
accountUUID.id
)
guard balance >= 0 else {
throw ZcashError.rustGetTransparentBalance(
Int(accountIndex.index),
lastErrorMessage(fallback: "Error getting Total Transparent balance from accountIndex \(accountIndex.index)")
accountUUID,
lastErrorMessage(fallback: "Error getting Total Transparent balance from accountUUID \(accountUUID.id)")
)
}
@ -300,19 +502,19 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
}
@DBActor
func getVerifiedTransparentBalance(accountIndex: Zip32AccountIndex) async throws -> Int64 {
func getVerifiedTransparentBalance(accountUUID: AccountUUID) async throws -> Int64 {
let balance = zcashlc_get_verified_transparent_balance_for_account(
dbData.0,
dbData.1,
networkType.networkId,
LCZip32Index(accountIndex.index),
accountUUID.id,
minimumShieldingConfirmations
)
guard balance >= 0 else {
throw ZcashError.rustGetVerifiedTransparentBalance(
Int(accountIndex.index),
lastErrorMessage(fallback: "Error getting verified transparent balance from accountIndex \(accountIndex.index)")
accountUUID,
lastErrorMessage(fallback: "Error getting verified transparent balance from accountUUID \(accountUUID.id)")
)
}
@ -416,11 +618,11 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
}
@DBActor
func listTransparentReceivers(accountIndex: Zip32AccountIndex) async throws -> [TransparentAddress] {
func listTransparentReceivers(accountUUID: AccountUUID) async throws -> [TransparentAddress] {
let encodedKeysPtr = zcashlc_list_transparent_receivers(
dbData.0,
dbData.1,
LCZip32Index(accountIndex.index),
accountUUID.id,
networkType.networkId
)
@ -659,11 +861,11 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
return nil
}
var accountBalances: [Zip32AccountIndex: AccountBalance] = [:]
var accountBalances: [AccountUUID: AccountBalance] = [:]
for i in (0 ..< Int(summaryPtr.pointee.account_balances_len)) {
let accountBalance = summaryPtr.pointee.account_balances.advanced(by: i).pointee
accountBalances[Zip32AccountIndex(accountBalance.account_id)] = accountBalance.toAccountBalance()
accountBalances[AccountUUID(id: accountBalance.uuidArray)] = accountBalance.toAccountBalance()
}
return WalletSummary(
@ -739,7 +941,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
@DBActor
func proposeShielding(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
memo: MemoBytes?,
shieldingThreshold: Zatoshi,
transparentReceiver: String?
@ -747,7 +949,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
let proposal = zcashlc_propose_shielding(
dbData.0,
dbData.1,
LCZip32Index(accountIndex.index),
accountUUID.id,
memo?.bytes,
UInt64(shieldingThreshold.amount),
transparentReceiver.map { [CChar]($0.utf8CString) },
@ -765,7 +967,7 @@ struct ZcashRustBackend: ZcashRustBackendWelding {
throw ZcashError.rustShieldFunds(lastErrorMessage(fallback: "Failed with nil pointer."))
}
return try FfiProposal(contiguousBytes: Data(
return try FfiProposal(serializedBytes: Data(
bytes: proposal.pointee.ptr,
count: Int(proposal.pointee.len)
))
@ -946,7 +1148,90 @@ extension String {
}
}
extension FfiAddress {
/// converts an [`FfiAddress`] into a [`UnifiedAddress`]
/// - Note: This does not check that the converted value actually holds a valid UnifiedAddress
func unsafeToUnifiedAddress(_ networkType: NetworkType) -> UnifiedAddress {
.init(validatedEncoding: String(cString: address), networkType: networkType)
}
}
extension FfiAccount {
var uuidArray: [UInt8] {
withUnsafeBytes(of: uuid_bytes) { buf in
[UInt8](buf)
}
}
var seedFingerprintArray: [UInt8] {
withUnsafeBytes(of: seed_fingerprint) { buf in
[UInt8](buf)
}
}
/// converts an [`FfiAccount`] into a [`Account`]
/// - Note: This does not check that the converted value actually holds a valid Account
func unsafeToAccount() -> Account? {
// Invalid UUID check
guard uuidArray != [UInt8](repeating: 0, count: 16) else {
return nil
}
// Invalid ZIP 32 account index
if hd_account_index == UInt32.max {
return .init(
id: AccountUUID(id: uuidArray),
name: account_name != nil ? String(cString: account_name) : nil,
keySource: key_source != nil ? String(cString: key_source) : nil,
seedFingerprint: nil,
hdAccountIndex: nil
)
}
// Valid ZIP32 account index
return .init(
id: AccountUUID(id: uuidArray),
name: account_name != nil ? String(cString: account_name) : nil,
keySource: key_source != nil ? String(cString: key_source) : nil,
seedFingerprint: seedFingerprintArray,
hdAccountIndex: Zip32AccountIndex(hd_account_index)
)
}
}
extension FfiBoxedSlice {
/// converts an [`FfiBoxedSlice`] into a [`UnifiedSpendingKey`]
/// - Note: This does not check that the converted value actually holds a valid USK
func unsafeToUnifiedSpendingKey(network: NetworkType) -> UnifiedSpendingKey {
.init(
network: network,
bytes: self.ptr.toByteArray(length: Int(self.len))
)
}
}
extension FfiUuid {
var uuidArray: [UInt8] {
withUnsafeBytes(of: self.uuid_bytes) { buf in
[UInt8](buf)
}
}
/// converts an [`FfiUuid`] into a [`AccountUUID`]
func unsafeToAccountUUID() -> AccountUUID {
.init(
id: self.uuidArray
)
}
}
extension FFIBinaryKey {
var uuidArray: [UInt8] {
withUnsafeBytes(of: self.account_uuid) { buf in
[UInt8](buf)
}
}
/// converts an [`FFIBinaryKey`] into a [`UnifiedSpendingKey`]
/// - Note: This does not check that the converted value actually holds a valid USK
func unsafeToUnifiedSpendingKey(network: NetworkType) -> UnifiedSpendingKey {
@ -954,8 +1239,7 @@ extension FFIBinaryKey {
network: network,
bytes: self.encoding.toByteArray(
length: Int(self.encoding_len)
),
accountIndex: Zip32AccountIndex(self.account_id)
)
)
}
}
@ -1001,6 +1285,12 @@ extension FfiBalance {
}
extension FfiAccountBalance {
var uuidArray: [UInt8] {
withUnsafeBytes(of: self.account_uuid) { buf in
[UInt8](buf)
}
}
/// Converts an [`FfiAccountBalance`] into a [`AccountBalance`].
func toAccountBalance() -> AccountBalance {
.init(

84
Sources/ZcashLightClientKit/Rust/ZcashRustBackendWelding.swift
View File

@ -35,9 +35,30 @@ public enum RewindResult {
}
protocol ZcashRustBackendWelding {
/// Returns a list of the ZIP 32 indices of accounts in the wallet.
func listAccounts() async throws -> [Zip32AccountIndex]
/// Returns a list of the accounts in the wallet.
func listAccounts() async throws -> [Account]
/// Adds a new account to the wallet by importing the UFVK that will be used to detect incoming
/// payments.
///
/// Derivation metadata may optionally be included. To indicate that no derivation metadata is
/// available, `seedFingerprint` and `zip32AccountIndex` should be set to `nil`. Derivation
/// metadata will not be stored unless both the seed fingerprint and the HD account index are
/// provided.
///
/// - Returns: the globally unique identifier for the account.
// swiftlint:disable:next function_parameter_count
func importAccount(
ufvk: String,
seedFingerprint: [UInt8]?,
zip32AccountIndex: Zip32AccountIndex?,
treeState: TreeState,
recoverUntil: UInt32?,
purpose: AccountPurpose,
name: String,
keySource: String?
) async throws -> AccountUUID
/// Adds the next available account-level spend authority, given the current set of [ZIP 316]
/// account identifiers known, to the wallet database.
///
@ -57,7 +78,13 @@ protocol ZcashRustBackendWelding {
/// - parameter recoverUntil: the fully-scanned height up to which the account will be treated as "being recovered"
/// - Returns: The `UnifiedSpendingKey` structs for the number of accounts created
/// - Throws: `rustCreateAccount`.
func createAccount(seed: [UInt8], treeState: TreeState, recoverUntil: UInt32?) async throws -> UnifiedSpendingKey
func createAccount(
seed: [UInt8],
treeState: TreeState,
recoverUntil: UInt32?,
name: String,
keySource: String?
) async throws -> UnifiedSpendingKey
/// Checks whether the given seed is relevant to any of the derived accounts in the wallet.
///
@ -75,14 +102,14 @@ protocol ZcashRustBackendWelding {
/// - Throws:
/// - `rustGetCurrentAddress` if rust layer returns error.
/// - `rustGetCurrentAddressInvalidAddress` if generated unified address isn't valid.
func getCurrentAddress(accountIndex: Zip32AccountIndex) async throws -> UnifiedAddress
func getCurrentAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress
/// Returns a newly-generated unified payment address for the specified account, with the next available diversifier.
/// - parameter account: index of the given account
/// - Throws:
/// - `rustGetNextAvailableAddress` if rust layer returns error.
/// - `rustGetNextAvailableAddressInvalidAddress` if generated unified address isn't valid.
func getNextAvailableAddress(accountIndex: Zip32AccountIndex) async throws -> UnifiedAddress
func getNextAvailableAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress
/// Get memo from note.
/// - parameter txId: ID of transaction containing the note
@ -95,7 +122,7 @@ protocol ZcashRustBackendWelding {
/// - Throws:
/// - `rustGetTransparentBalanceNegativeAccount` if `account` is < 0.
/// - `rustGetTransparentBalance` if rust layer returns error.
func getTransparentBalance(accountIndex: Zip32AccountIndex) async throws -> Int64
func getTransparentBalance(accountUUID: AccountUUID) async throws -> Int64
/// Initializes the data db. This will performs any migrations needed on the sqlite file
/// provided. Some migrations might need that callers provide the seed bytes.
@ -112,14 +139,14 @@ protocol ZcashRustBackendWelding {
/// - Throws:
/// - `rustListTransparentReceivers` if rust layer returns error.
/// - `rustListTransparentReceiversInvalidAddress` if transarent received generated by rust is invalid.
func listTransparentReceivers(accountIndex: Zip32AccountIndex) async throws -> [TransparentAddress]
func listTransparentReceivers(accountUUID: AccountUUID) async throws -> [TransparentAddress]
/// Get the verified cached transparent balance for the given account
/// - parameter account: account index to query the balance for.
/// - Throws:
/// - `rustGetVerifiedTransparentBalanceNegativeAccount` if `account` is < 0.
/// - `rustGetVerifiedTransparentBalance` if rust layer returns error.
func getVerifiedTransparentBalance(accountIndex: Zip32AccountIndex) async throws -> Int64
func getVerifiedTransparentBalance(accountUUID: AccountUUID) async throws -> Int64
/// Resets the state of the database to only contain block and transaction information up to the given height. clears up all derived data as well
/// - parameter height: height to rewind to.
@ -217,7 +244,7 @@ protocol ZcashRustBackendWelding {
/// - Parameter memo: the `MemoBytes` for this transaction. pass `nil` when sending to transparent receivers
/// - Throws: `rustCreateToAddress`.
func proposeTransfer(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
to address: String,
value: Int64,
memo: MemoBytes?
@ -229,13 +256,10 @@ protocol ZcashRustBackendWelding {
///
/// - parameter uri: the URI String that the proposal will be made from.
/// - parameter account: index of the given account
/// - Parameter to: recipient address
/// - Parameter value: transaction amount in Zatoshi
/// - Parameter memo: the `MemoBytes` for this transaction. pass `nil` when sending to transparent receivers
/// - Throws: `rustCreateToAddress`.
func proposeTransferFromURI(
_ uri: String,
accountIndex: Zip32AccountIndex
accountUUID: AccountUUID
) async throws -> FfiProposal
/// Constructs a transaction proposal to shield all found UTXOs in data db for the given account,
@ -253,7 +277,7 @@ protocol ZcashRustBackendWelding {
/// to shield.
/// - Throws: `rustShieldFunds` if rust layer returns error.
func proposeShielding(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
memo: MemoBytes?,
shieldingThreshold: Zatoshi,
transparentReceiver: String?
@ -268,6 +292,38 @@ protocol ZcashRustBackendWelding {
usk: UnifiedSpendingKey
) async throws -> [Data]
/// Creates a partially-created (unsigned without proofs) transaction from the given proposal.
///
/// Do not call this multiple times in parallel, or you will generate PCZT instances that, if
/// finalized, would double-spend the same notes.
///
/// - Parameter accountUUID: The account for which the proposal was created.
/// - Parameter proposal: The proposal for which to create the transaction.
/// - Returns The partially created transaction in [Pczt] format.
///
/// - Throws rustCreatePCZTFromProposal as a common indicator of the operation failure
func createPCZTFromProposal(accountUUID: AccountUUID, proposal: FfiProposal) async throws -> Pczt
/// Adds proofs to the given PCZT.
///
/// - Parameter pczt: The partially created transaction in its serialized format.
///
/// - Returns The updated PCZT in its serialized format.
///
/// - Throws rustAddProofsToPCZT as a common indicator of the operation failure
func addProofsToPCZT(pczt: Pczt) async throws -> Pczt
/// Takes a PCZT that has been separately proven and signed, finalizes it, and stores
/// it in the wallet. Internally, this logic also submits and checks the newly stored and encoded transaction.
///
/// - Parameter pcztWithProofs
/// - Parameter pcztWithSigs
///
/// - Returns The submission result of the completed transaction.
///
/// - Throws PcztException.ExtractAndStoreTxFromPcztException as a common indicator of the operation failure
func extractAndStoreTxFromPCZT(pcztWithProofs: Pczt, pcztWithSigs: Pczt) async throws -> Data
/// Gets the consensus branch id for the given height
/// - Parameter height: the height you what to know the branch id for
/// - Throws: `rustNoConsensusBranchId` if rust layer returns error.

115
Sources/ZcashLightClientKit/Synchronizer.swift
View File

@ -36,7 +36,7 @@ public struct SynchronizerState: Equatable {
/// SyncSessionIDs are provided to users
public var syncSessionID: UUID
/// account balance known to this synchronizer given the data that has processed locally
public var accountsBalances: [Zip32AccountIndex: AccountBalance]
public var accountsBalances: [AccountUUID: AccountBalance]
/// status of the whole sync process
var internalSyncStatus: InternalSyncStatus
public var syncStatus: SyncStatus
@ -55,7 +55,7 @@ public struct SynchronizerState: Equatable {
init(
syncSessionID: UUID,
accountsBalances: [Zip32AccountIndex: AccountBalance],
accountsBalances: [AccountUUID: AccountBalance],
internalSyncStatus: InternalSyncStatus,
latestBlockHeight: BlockHeight
) {
@ -120,6 +120,8 @@ public protocol Synchronizer: AnyObject {
/// - for: [walletMode] Set `.newWallet` when preparing synchronizer for a brand new generated wallet,
/// `.restoreWallet` when wallet is about to be restored from a seed
/// and `.existingWallet` for all other scenarios.
/// - name: name of the account.
/// - keySource: custom optional string for clients, used for example to help identify the type of the account.
/// - Throws:
/// - `aliasAlreadyInUse` if the Alias used to create this instance is already used by other instance.
/// - `cantUpdateURLWithAlias` if the updating of paths in `Initilizer` according to alias fails. When this happens it means that
@ -129,7 +131,9 @@ public protocol Synchronizer: AnyObject {
func prepare(
with seed: [UInt8]?,
walletBirthday: BlockHeight,
for walletMode: WalletInitMode
for walletMode: WalletInitMode,
name: String,
keySource: String?
) async throws -> Initializer.InitializationResult
/// Starts this synchronizer within the given scope.
@ -144,23 +148,23 @@ public protocol Synchronizer: AnyObject {
func stop()
/// Gets the sapling shielded address for the given account.
/// - Parameter accountIndex: the ZIP 32 index of the account whose address is of interest.
/// - Parameter accountUUID: the account whose address is of interest.
/// - Returns the address or nil if account index is incorrect
func getSaplingAddress(accountIndex: Zip32AccountIndex) async throws -> SaplingAddress
func getSaplingAddress(accountUUID: AccountUUID) async throws -> SaplingAddress
/// Gets the unified address for the given account.
/// - Parameter accountIndex: the ZIP 32 index of the account whose address is of interest.
/// - Parameter accountUUID: the account whose address is of interest.
/// - Returns the address or nil if account index is incorrect
func getUnifiedAddress(accountIndex: Zip32AccountIndex) async throws -> UnifiedAddress
func getUnifiedAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress
/// Gets the transparent address for the given account.
/// - Parameter accountIndex: the ZIP 32 index of the account whose address is of interest. By default, the first account is used.
/// - Parameter accountUUID: the account whose address is of interest. By default, the first account is used.
/// - Returns the address or nil if account index is incorrect
func getTransparentAddress(accountIndex: Zip32AccountIndex) async throws -> TransparentAddress
func getTransparentAddress(accountUUID: AccountUUID) async throws -> TransparentAddress
/// Creates a proposal for transferring funds to the given recipient.
///
/// - Parameter accountIndex: the ZIP 32 index of the account from which to transfer funds.
/// - Parameter accountUUID: the account from which to transfer funds.
/// - Parameter recipient: the recipient's address.
/// - Parameter amount: the amount to send in Zatoshi.
/// - Parameter memo: an optional memo to include as part of the proposal's transactions. Use `nil` when sending to transparent receivers otherwise the function will throw an error.
@ -168,7 +172,7 @@ public protocol Synchronizer: AnyObject {
/// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
/// `SynchronizerErrors.notPrepared`.
func proposeTransfer(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
recipient: Recipient,
amount: Zatoshi,
memo: Memo?
@ -176,7 +180,7 @@ public protocol Synchronizer: AnyObject {
/// Creates a proposal for shielding any transparent funds received by the given account.
///
/// - Parameter accountIndex: the ZIP 32 index of the account for which to shield funds.
/// - Parameter accountUUID: the account for which to shield funds.
/// - Parameter shieldingThreshold: the minimum transparent balance required before a proposal will be created.
/// - Parameter memo: an optional memo to include as part of the proposal's transactions.
/// - Parameter transparentReceiver: a specific transparent receiver within the account
@ -190,7 +194,7 @@ public protocol Synchronizer: AnyObject {
/// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
/// `SynchronizerErrors.notPrepared`.
func proposeShielding(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
shieldingThreshold: Zatoshi,
memo: Memo,
transparentReceiver: TransparentAddress?
@ -212,46 +216,48 @@ public protocol Synchronizer: AnyObject {
spendingKey: UnifiedSpendingKey
) async throws -> AsyncThrowingStream<TransactionSubmitResult, Error>
/// Sends zatoshi.
/// - Parameter spendingKey: the `UnifiedSpendingKey` that allows spends to occur.
/// - Parameter zatoshi: the amount to send in Zatoshi.
/// - Parameter toAddress: the recipient's address.
/// - Parameter memo: an `Optional<Memo>`with the memo to include as part of the transaction. send `nil` when sending to transparent receivers otherwise the function will throw an error
///
/// - NOTE: If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then this method throws
/// `SynchronizerErrors.notPrepared`.
@available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
func sendToAddress(
spendingKey: UnifiedSpendingKey,
zatoshi: Zatoshi,
toAddress: Recipient,
memo: Memo?
) async throws -> ZcashTransaction.Overview
/// Attempts to propose fulfilling a [ZIP-321](https://zips.z.cash/zip-0321) payment URI by spending from the ZIP 32 account with the given index.
/// - Parameter uri: a valid ZIP-321 payment URI
/// - Parameter accountIndex: the ZIP 32 index of the account providing spend authority.
/// - Parameter accountUUID: the account providing spend authority.
///
/// - NOTE: If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then this method throws
/// `SynchronizerErrors.notPrepared`.
func proposefulfillingPaymentURI(
_ uri: String,
accountIndex: Zip32AccountIndex
accountUUID: AccountUUID
) async throws -> Proposal
/// Shields transparent funds from the given private key into the best shielded pool of the account associated to the given `UnifiedSpendingKey`.
/// - Parameter spendingKey: the `UnifiedSpendingKey` that allows to spend transparent funds
/// - Parameter memo: the optional memo to include as part of the transaction.
/// - Parameter shieldingThreshold: the minimum transparent balance required before a transaction will be created.
/// Creates a partially-created (unsigned without proofs) transaction from the given proposal.
///
/// - Note: If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then this method throws
/// `SynchronizerErrors.notPrepared`.
@available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
func shieldFunds(
spendingKey: UnifiedSpendingKey,
memo: Memo,
shieldingThreshold: Zatoshi
) async throws -> ZcashTransaction.Overview
/// Do not call this multiple times in parallel, or you will generate PCZT instances that, if
/// finalized, would double-spend the same notes.
///
/// - Parameter accountUUID: The account for which the proposal was created.
/// - Parameter proposal: The proposal for which to create the transaction.
/// - Returns The partially created transaction in [Pczt] format.
///
/// - Throws rustCreatePCZTFromProposal as a common indicator of the operation failure
func createPCZTFromProposal(accountUUID: AccountUUID, proposal: Proposal) async throws -> Pczt
/// Adds proofs to the given PCZT.
///
/// - Parameter pczt: The partially created transaction in its serialized format.
///
/// - Returns The updated PCZT in its serialized format.
///
/// - Throws rustAddProofsToPCZT as a common indicator of the operation failure
func addProofsToPCZT(pczt: Pczt) async throws -> Pczt
/// Takes a PCZT that has been separately proven and signed, finalizes it, and stores
/// it in the wallet. Internally, this logic also submits and checks the newly stored and encoded transaction.
///
/// - Parameter pcztWithProofs
/// - Parameter pcztWithSigs
///
/// - Returns The submission result of the completed transaction.
///
/// - Throws PcztException.ExtractAndStoreTxFromPcztException as a common indicator of the operation failure
func createTransactionFromPCZT(pcztWithProofs: Pczt, pcztWithSigs: Pczt) async throws -> AsyncThrowingStream<TransactionSubmitResult, Error>
/// all the transactions that are on the blockchain
var transactions: [ZcashTransaction.Overview] { get async }
@ -308,12 +314,31 @@ public protocol Synchronizer: AnyObject {
func refreshUTXOs(address: TransparentAddress, from height: BlockHeight) async throws -> RefreshedUTXOs
/// Accounts balances
/// - Returns: `[Zip32AccountIndex: AccountBalance]`, struct that holds Sapling and unshielded balances per account
func getAccountsBalances() async throws -> [Zip32AccountIndex: AccountBalance]
/// - Returns: `[AccountUUID: AccountBalance]`, struct that holds Sapling and unshielded balances per account
func getAccountsBalances() async throws -> [AccountUUID: AccountBalance]
/// Fetches the latest ZEC-USD exchange rate and updates `exchangeRateUSDSubject`.
func refreshExchangeRateUSD()
/// Returns a list of the accounts in the wallet.
func listAccounts() async throws -> [Account]
/// Imports a new account with UnifiedFullViewingKey.
/// - Parameters:
/// - ufvk: unified full viewing key
/// - purpose: of the account, either `spending` or `viewOnly`
/// - name: name of the account.
/// - keySource: custom optional string for clients, used for example to help identify the type of the account.
// swiftlint:disable:next function_parameter_count
func importAccount(
ufvk: String,
seedFingerprint: [UInt8]?,
zip32AccountIndex: Zip32AccountIndex?,
purpose: AccountPurpose,
name: String,
keySource: String?
) async throws -> AccountUUID
/// Rescans the known blocks with the current keys.
///
/// `rewind(policy:)` can be called anytime. If the sync process is in progress then it is stopped first. In this case, it make some significant

94
Sources/ZcashLightClientKit/Synchronizer/ClosureSDKSynchronizer.swift
View File

@ -35,10 +35,18 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
with seed: [UInt8]?,
walletBirthday: BlockHeight,
for walletMode: WalletInitMode,
name: String,
keySource: String?,
completion: @escaping (Result<Initializer.InitializationResult, Error>) -> Void
) {
AsyncToClosureGateway.executeThrowingAction(completion) {
return try await self.synchronizer.prepare(with: seed, walletBirthday: walletBirthday, for: walletMode)
return try await self.synchronizer.prepare(
with: seed,
walletBirthday: walletBirthday,
for: walletMode,
name: name,
keySource: keySource
)
}
}
@ -52,38 +60,66 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
synchronizer.stop()
}
public func getSaplingAddress(accountIndex: Zip32AccountIndex, completion: @escaping (Result<SaplingAddress, Error>) -> Void) {
public func getSaplingAddress(accountUUID: AccountUUID, completion: @escaping (Result<SaplingAddress, Error>) -> Void) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.getSaplingAddress(accountIndex: accountIndex)
try await self.synchronizer.getSaplingAddress(accountUUID: accountUUID)
}
}
public func getUnifiedAddress(accountIndex: Zip32AccountIndex, completion: @escaping (Result<UnifiedAddress, Error>) -> Void) {
public func getUnifiedAddress(accountUUID: AccountUUID, completion: @escaping (Result<UnifiedAddress, Error>) -> Void) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.getUnifiedAddress(accountIndex: accountIndex)
try await self.synchronizer.getUnifiedAddress(accountUUID: accountUUID)
}
}
public func getTransparentAddress(accountIndex: Zip32AccountIndex, completion: @escaping (Result<TransparentAddress, Error>) -> Void) {
public func getTransparentAddress(accountUUID: AccountUUID, completion: @escaping (Result<TransparentAddress, Error>) -> Void) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.getTransparentAddress(accountIndex: accountIndex)
try await self.synchronizer.getTransparentAddress(accountUUID: accountUUID)
}
}
public func listAccounts(completion: @escaping (Result<[Account], Error>) -> Void) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.listAccounts()
}
}
// swiftlint:disable:next function_parameter_count
public func importAccount(
ufvk: String,
seedFingerprint: [UInt8]?,
zip32AccountIndex: Zip32AccountIndex?,
purpose: AccountPurpose,
name: String,
keySource: String?,
completion: @escaping (Result<AccountUUID, Error>) -> Void
) async throws {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.importAccount(
ufvk: ufvk,
seedFingerprint: seedFingerprint,
zip32AccountIndex: zip32AccountIndex,
purpose: purpose,
name: name,
keySource: keySource
)
}
}
public func proposeTransfer(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
recipient: Recipient,
amount: Zatoshi,
memo: Memo?,
completion: @escaping (Result<Proposal, Error>) -> Void
) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.proposeTransfer(accountIndex: accountIndex, recipient: recipient, amount: amount, memo: memo)
try await self.synchronizer.proposeTransfer(accountUUID: accountUUID, recipient: recipient, amount: amount, memo: memo)
}
}
public func proposeShielding(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
shieldingThreshold: Zatoshi,
memo: Memo,
transparentReceiver: TransparentAddress? = nil,
@ -91,7 +127,7 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.proposeShielding(
accountIndex: accountIndex,
accountUUID: accountUUID,
shieldingThreshold: shieldingThreshold,
memo: memo,
transparentReceiver: transparentReceiver
@ -109,28 +145,32 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
}
}
@available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
public func sendToAddress(
spendingKey: UnifiedSpendingKey,
zatoshi: Zatoshi,
toAddress: Recipient,
memo: Memo?,
completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
public func createPCZTFromProposal(
accountUUID: AccountUUID,
proposal: Proposal,
completion: @escaping (Result<Pczt, Error>) -> Void
) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.sendToAddress(spendingKey: spendingKey, zatoshi: zatoshi, toAddress: toAddress, memo: memo)
try await self.synchronizer.createPCZTFromProposal(accountUUID: accountUUID, proposal: proposal)
}
}
@available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
public func shieldFunds(
spendingKey: UnifiedSpendingKey,
memo: Memo,
shieldingThreshold: Zatoshi,
completion: @escaping (Result<ZcashTransaction.Overview, Error>) -> Void
public func addProofsToPCZT(
pczt: Pczt,
completion: @escaping (Result<Pczt, Error>) -> Void
) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.shieldFunds(spendingKey: spendingKey, memo: memo, shieldingThreshold: shieldingThreshold)
try await self.synchronizer.addProofsToPCZT(pczt: pczt)
}
}
public func createTransactionFromPCZT(
pcztWithProofs: Pczt,
pcztWithSigs: Pczt,
completion: @escaping (Result<AsyncThrowingStream<TransactionSubmitResult, Error>, Error>) -> Void
) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.createTransactionFromPCZT(pcztWithProofs: pcztWithProofs, pcztWithSigs: pcztWithSigs)
}
}
@ -188,7 +228,7 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
}
}
public func getAccountsBalances(completion: @escaping (Result<[Zip32AccountIndex: AccountBalance], Error>) -> Void) {
public func getAccountsBalances(_ completion: @escaping (Result<[AccountUUID: AccountBalance], Error>) -> Void) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.getAccountsBalances()
}

98
Sources/ZcashLightClientKit/Synchronizer/CombineSDKSynchronizer.swift
View File

@ -34,10 +34,18 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
public func prepare(
with seed: [UInt8]?,
walletBirthday: BlockHeight,
for walletMode: WalletInitMode
for walletMode: WalletInitMode,
name: String,
keySource: String?
) -> SinglePublisher<Initializer.InitializationResult, Error> {
AsyncToCombineGateway.executeThrowingAction() {
return try await self.synchronizer.prepare(with: seed, walletBirthday: walletBirthday, for: walletMode)
return try await self.synchronizer.prepare(
with: seed,
walletBirthday: walletBirthday,
for: walletMode,
name: name,
keySource: keySource
)
}
}
@ -51,56 +59,56 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
synchronizer.stop()
}
public func getSaplingAddress(accountIndex: Zip32AccountIndex) -> SinglePublisher<SaplingAddress, Error> {
public func getSaplingAddress(accountUUID: AccountUUID) -> SinglePublisher<SaplingAddress, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.getSaplingAddress(accountIndex: accountIndex)
try await self.synchronizer.getSaplingAddress(accountUUID: accountUUID)
}
}
public func getUnifiedAddress(accountIndex: Zip32AccountIndex) -> SinglePublisher<UnifiedAddress, Error> {
public func getUnifiedAddress(accountUUID: AccountUUID) -> SinglePublisher<UnifiedAddress, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.getUnifiedAddress(accountIndex: accountIndex)
try await self.synchronizer.getUnifiedAddress(accountUUID: accountUUID)
}
}
public func getTransparentAddress(accountIndex: Zip32AccountIndex) -> SinglePublisher<TransparentAddress, Error> {
public func getTransparentAddress(accountUUID: AccountUUID) -> SinglePublisher<TransparentAddress, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.getTransparentAddress(accountIndex: accountIndex)
try await self.synchronizer.getTransparentAddress(accountUUID: accountUUID)
}
}
public func proposeTransfer(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
recipient: Recipient,
amount: Zatoshi,
memo: Memo?
) -> SinglePublisher<Proposal, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.proposeTransfer(accountIndex: accountIndex, recipient: recipient, amount: amount, memo: memo)
try await self.synchronizer.proposeTransfer(accountUUID: accountUUID, recipient: recipient, amount: amount, memo: memo)
}
}
public func proposefulfillingPaymentURI(
_ uri: String,
accountIndex: Zip32AccountIndex
accountUUID: AccountUUID
) -> SinglePublisher<Proposal, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.proposefulfillingPaymentURI(
uri,
accountIndex: accountIndex
accountUUID: accountUUID
)
}
}
public func proposeShielding(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
shieldingThreshold: Zatoshi,
memo: Memo,
transparentReceiver: TransparentAddress? = nil
) -> SinglePublisher<Proposal?, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.proposeShielding(
accountIndex: accountIndex,
accountUUID: accountUUID,
shieldingThreshold: shieldingThreshold,
memo: memo,
transparentReceiver: transparentReceiver
@ -117,26 +125,56 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
}
}
@available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
public func sendToAddress(
spendingKey: UnifiedSpendingKey,
zatoshi: Zatoshi,
toAddress: Recipient,
memo: Memo?
) -> SinglePublisher<ZcashTransaction.Overview, Error> {
public func createPCZTFromProposal(
accountUUID: AccountUUID,
proposal: Proposal
) -> SinglePublisher<Pczt, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.sendToAddress(spendingKey: spendingKey, zatoshi: zatoshi, toAddress: toAddress, memo: memo)
try await self.synchronizer.createPCZTFromProposal(accountUUID: accountUUID, proposal: proposal)
}
}
@available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
public func shieldFunds(
spendingKey: UnifiedSpendingKey,
memo: Memo,
shieldingThreshold: Zatoshi
) -> SinglePublisher<ZcashTransaction.Overview, Error> {
public func addProofsToPCZT(
pczt: Pczt
) -> SinglePublisher<Pczt, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.shieldFunds(spendingKey: spendingKey, memo: memo, shieldingThreshold: shieldingThreshold)
try await self.synchronizer.addProofsToPCZT(pczt: pczt)
}
}
public func createTransactionFromPCZT(
pcztWithProofs: Pczt,
pcztWithSigs: Pczt
) -> SinglePublisher<AsyncThrowingStream<TransactionSubmitResult, Error>, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.createTransactionFromPCZT(pcztWithProofs: pcztWithProofs, pcztWithSigs: pcztWithSigs)
}
}
public func listAccounts() -> SinglePublisher<[Account], Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.listAccounts()
}
}
// swiftlint:disable:next function_parameter_count
public func importAccount(
ufvk: String,
seedFingerprint: [UInt8]?,
zip32AccountIndex: Zip32AccountIndex?,
purpose: AccountPurpose,
name: String,
keySource: String?
) async throws -> SinglePublisher<AccountUUID, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.importAccount(
ufvk: ufvk,
seedFingerprint: seedFingerprint,
zip32AccountIndex: zip32AccountIndex,
purpose: purpose,
name: name,
keySource: keySource
)
}
}
@ -190,7 +228,7 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
}
}
public func getAccountsBalances() -> SinglePublisher<[Zip32AccountIndex: AccountBalance], Error> {
public func getAccountsBalances() -> SinglePublisher<[AccountUUID: AccountBalance], Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.getAccountsBalances()
}

196
Sources/ZcashLightClientKit/Synchronizer/SDKSynchronizer.swift
View File

@ -97,7 +97,6 @@ public class SDKSynchronizer: Synchronizer {
}
deinit {
UsedAliasesChecker.stopUsing(alias: initializer.alias, id: initializer.id)
Task { [blockProcessor] in
await blockProcessor.stop()
}
@ -120,17 +119,15 @@ public class SDKSynchronizer: Synchronizer {
return initialisationError
}
if !UsedAliasesChecker.tryToUse(alias: initializer.alias, id: initializer.id) {
return .initializerAliasAlreadyInUse(initializer.alias)
}
return nil
}
public func prepare(
with seed: [UInt8]?,
walletBirthday: BlockHeight,
for walletMode: WalletInitMode
for walletMode: WalletInitMode,
name: String,
keySource: String?
) async throws -> Initializer.InitializationResult {
guard await status == .unprepared else { return .success }
@ -138,7 +135,13 @@ public class SDKSynchronizer: Synchronizer {
throw error
}
if case .seedRequired = try await self.initializer.initialize(with: seed, walletBirthday: walletBirthday, for: walletMode) {
if case .seedRequired = try await self.initializer.initialize(
with: seed,
walletBirthday: walletBirthday,
for: walletMode,
name: name,
keySource: keySource
) {
return .seedRequired
}
@ -265,7 +268,42 @@ public class SDKSynchronizer: Synchronizer {
// MARK: Synchronizer methods
public func proposeTransfer(accountIndex: Zip32AccountIndex, recipient: Recipient, amount: Zatoshi, memo: Memo?) async throws -> Proposal {
public func listAccounts() async throws -> [Account] {
try await initializer.rustBackend.listAccounts()
}
// swiftlint:disable:next function_parameter_count
public func importAccount(
ufvk: String,
seedFingerprint: [UInt8]?,
zip32AccountIndex: Zip32AccountIndex?,
purpose: AccountPurpose,
name: String,
keySource: String?
) async throws -> AccountUUID {
let chainTip = try? await UInt32(initializer.lightWalletService.latestBlockHeight())
let checkpointSource = initializer.container.resolve(CheckpointSource.self)
guard let chainTip else {
throw ZcashError.synchronizerNotPrepared
}
let checkpoint = checkpointSource.birthday(for: BlockHeight(chainTip))
return try await initializer.rustBackend.importAccount(
ufvk: ufvk,
seedFingerprint: seedFingerprint,
zip32AccountIndex: zip32AccountIndex,
treeState: checkpoint.treeState(),
recoverUntil: chainTip,
purpose: purpose,
name: name,
keySource: keySource
)
}
public func proposeTransfer(accountUUID: AccountUUID, recipient: Recipient, amount: Zatoshi, memo: Memo?) async throws -> Proposal {
try throwIfUnprepared()
if case Recipient.transparent = recipient, memo != nil {
@ -273,7 +311,7 @@ public class SDKSynchronizer: Synchronizer {
}
let proposal = try await transactionEncoder.proposeTransfer(
accountIndex: accountIndex,
accountUUID: accountUUID,
recipient: recipient.stringEncoded,
amount: amount,
memoBytes: memo?.asMemoBytes()
@ -283,7 +321,7 @@ public class SDKSynchronizer: Synchronizer {
}
public func proposeShielding(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
shieldingThreshold: Zatoshi,
memo: Memo,
transparentReceiver: TransparentAddress? = nil
@ -291,7 +329,7 @@ public class SDKSynchronizer: Synchronizer {
try throwIfUnprepared()
return try await transactionEncoder.proposeShielding(
accountIndex: accountIndex,
accountUUID: accountUUID,
shieldingThreshold: shieldingThreshold,
memoBytes: memo.asMemoBytes(),
transparentReceiver: transparentReceiver?.stringEncoded
@ -300,13 +338,13 @@ public class SDKSynchronizer: Synchronizer {
public func proposefulfillingPaymentURI(
_ uri: String,
accountIndex: Zip32AccountIndex
accountUUID: AccountUUID
) async throws -> Proposal {
do {
try throwIfUnprepared()
return try await transactionEncoder.proposeFulfillingPaymentFromURI(
uri,
accountIndex: accountIndex
accountUUID: accountUUID
)
} catch ZcashError.rustCreateToAddress(let error) {
throw ZcashError.rustProposeTransferFromURI(error)
@ -333,6 +371,11 @@ public class SDKSynchronizer: Synchronizer {
proposal: proposal,
spendingKey: spendingKey
)
return submitTransactions(transactions)
}
func submitTransactions(_ transactions: [ZcashTransaction.Overview]) -> AsyncThrowingStream<TransactionSubmitResult, Error> {
var iterator = transactions.makeIterator()
var submitFailed = false
@ -357,19 +400,23 @@ public class SDKSynchronizer: Synchronizer {
}
}
}
public func sendToAddress(
spendingKey: UnifiedSpendingKey,
zatoshi: Zatoshi,
toAddress: Recipient,
memo: Memo?
) async throws -> ZcashTransaction.Overview {
public func createPCZTFromProposal(accountUUID: AccountUUID, proposal: Proposal) async throws -> Pczt {
try await initializer.rustBackend.createPCZTFromProposal(
accountUUID: accountUUID,
proposal: proposal.inner
)
}
public func addProofsToPCZT(pczt: Pczt) async throws -> Pczt {
try await initializer.rustBackend.addProofsToPCZT(
pczt: pczt
)
}
public func createTransactionFromPCZT(pcztWithProofs: Pczt, pcztWithSigs: Pczt) async throws -> AsyncThrowingStream<TransactionSubmitResult, Error> {
try throwIfUnprepared()
if case Recipient.transparent = toAddress, memo != nil {
throw ZcashError.synchronizerSendMemoToTransparentAddress
}
try await SaplingParameterDownloader.downloadParamsIfnotPresent(
spendURL: initializer.spendParamsURL,
spendSourceURL: initializer.saplingParamsSourceURL.spendParamFileURL,
@ -378,89 +425,14 @@ public class SDKSynchronizer: Synchronizer {
logger: logger
)
return try await createToAddress(
spendingKey: spendingKey,
zatoshi: zatoshi,
recipient: toAddress,
memo: memo
)
}
public func shieldFunds(
spendingKey: UnifiedSpendingKey,
memo: Memo,
shieldingThreshold: Zatoshi
) async throws -> ZcashTransaction.Overview {
try throwIfUnprepared()
// let's see if there are funds to shield
guard let tBalance = try await self.getAccountsBalances()[spendingKey.accountIndex]?.unshielded else {
throw ZcashError.synchronizerSpendingKeyDoesNotBelongToTheWallet
}
// Verify that at least there are funds for the fee. Ideally this logic will be improved by the shielding wallet.
guard tBalance >= self.network.constants.defaultFee() else {
throw ZcashError.synchronizerShieldFundsInsuficientTransparentFunds
}
guard let proposal = try await transactionEncoder.proposeShielding(
accountIndex: spendingKey.accountIndex,
shieldingThreshold: shieldingThreshold,
memoBytes: memo.asMemoBytes(),
transparentReceiver: nil
) else { throw ZcashError.synchronizerShieldFundsInsuficientTransparentFunds }
let transactions = try await transactionEncoder.createProposedTransactions(
proposal: proposal,
spendingKey: spendingKey
let txId = try await initializer.rustBackend.extractAndStoreTxFromPCZT(
pcztWithProofs: pcztWithProofs,
pcztWithSigs: pcztWithSigs
)
assert(transactions.count == 1, "Rust backend doesn't produce multiple transactions yet")
let transaction = transactions[0]
let encodedTx = try transaction.encodedTransaction()
try await transactionEncoder.submit(transaction: encodedTx)
return transaction
}
func createToAddress(
spendingKey: UnifiedSpendingKey,
zatoshi: Zatoshi,
recipient: Recipient,
memo: Memo?
) async throws -> ZcashTransaction.Overview {
do {
if
case .transparent = recipient,
memo != nil {
throw ZcashError.synchronizerSendMemoToTransparentAddress
}
let proposal = try await transactionEncoder.proposeTransfer(
accountIndex: spendingKey.accountIndex,
recipient: recipient.stringEncoded,
amount: zatoshi,
memoBytes: memo?.asMemoBytes()
)
let transactions = try await transactionEncoder.createProposedTransactions(
proposal: proposal,
spendingKey: spendingKey
)
assert(transactions.count == 1, "Rust backend doesn't produce multiple transactions yet")
let transaction = transactions[0]
let encodedTransaction = try transaction.encodedTransaction()
try await transactionEncoder.submit(transaction: encodedTransaction)
return transaction
} catch {
throw error
}
let transactions = try await transactionEncoder.fetchTransactionsForTxIds([txId])
return submitTransactions(transactions)
}
public func allReceivedTransactions() async throws -> [ZcashTransaction.Overview] {
@ -508,7 +480,7 @@ public class SDKSynchronizer: Synchronizer {
return try await blockProcessor.refreshUTXOs(tAddress: address, startHeight: height)
}
public func getAccountsBalances() async throws -> [Zip32AccountIndex: AccountBalance] {
public func getAccountsBalances() async throws -> [AccountUUID: AccountBalance] {
try await initializer.rustBackend.getWalletSummary()?.accountBalances ?? [:]
}
@ -547,16 +519,16 @@ public class SDKSynchronizer: Synchronizer {
}
}
public func getUnifiedAddress(accountIndex: Zip32AccountIndex) async throws -> UnifiedAddress {
try await blockProcessor.getUnifiedAddress(accountIndex: accountIndex)
public func getUnifiedAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress {
try await blockProcessor.getUnifiedAddress(accountUUID: accountUUID)
}
public func getSaplingAddress(accountIndex: Zip32AccountIndex) async throws -> SaplingAddress {
try await blockProcessor.getSaplingAddress(accountIndex: accountIndex)
public func getSaplingAddress(accountUUID: AccountUUID) async throws -> SaplingAddress {
try await blockProcessor.getSaplingAddress(accountUUID: accountUUID)
}
public func getTransparentAddress(accountIndex: Zip32AccountIndex) async throws -> TransparentAddress {
try await blockProcessor.getTransparentAddress(accountIndex: accountIndex)
public func getTransparentAddress(accountUUID: AccountUUID) async throws -> TransparentAddress {
try await blockProcessor.getTransparentAddress(accountUUID: accountUUID)
}
// MARK: Rewind

12
Sources/ZcashLightClientKit/Tool/DerivationTool.swift
View File

@ -17,6 +17,11 @@ public protocol KeyValidation {
}
public protocol KeyDeriving {
/// Derives and returns a UnifiedAddress from a UnifiedFullViewingKey
/// - Parameter ufvk: UTF-8 encoded String containing a valid UFVK
/// - Returns: the corresponding default `UnifiedAddress`
func deriveUnifiedAddressFrom(ufvk: String) throws -> UnifiedAddress
/// Given the seed bytes and ZIP 32 account index, return the corresponding UnifiedSpendingKey.
/// - Parameter seed: `[Uint8]` seed bytes
/// - Parameter accountIndex: the ZIP 32 index of the account
@ -92,6 +97,10 @@ public class DerivationTool: KeyDeriving {
ZcashKeyDerivationBackend.getAddressMetadata(addr)
}
public func deriveUnifiedAddressFrom(ufvk: String) throws -> UnifiedAddress {
try backend.deriveUnifiedAddressFrom(ufvk: ufvk)
}
/// 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.
@ -233,9 +242,8 @@ extension UnifiedFullViewingKey {
/// 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, accountIndex: Zip32AccountIndex) {
init(validatedEncoding: String) {
self.encoding = validatedEncoding
self.accountIndex = accountIndex
}
}

16
Sources/ZcashLightClientKit/Transaction/TransactionEncoder.swift
View File

@ -21,7 +21,7 @@ public enum TransactionEncoderError: Error {
protocol TransactionEncoder {
/// Creates a proposal for transferring funds to the given recipient.
///
/// - Parameter accountIndex: the ZIP 32 index of the account from which to transfer funds.
/// - Parameter accountUUID: the account from which to transfer funds.
/// - Parameter recipient: string containing the recipient's address.
/// - Parameter amount: the amount to send in Zatoshi.
/// - Parameter memoBytes: an optional memo to include as part of the proposal's transactions. Use `nil` when sending to transparent receivers otherwise the function will throw an error.
@ -29,7 +29,7 @@ protocol TransactionEncoder {
/// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
/// `SynchronizerErrors.notPrepared`.
func proposeTransfer(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
recipient: String,
amount: Zatoshi,
memoBytes: MemoBytes?
@ -37,7 +37,7 @@ protocol TransactionEncoder {
/// Creates a proposal for shielding any transparent funds received by the given account.
///
/// - Parameter accountIndex: the ZIP 32 index of the account from which to shield funds.
/// - Parameter accountUUID:the account from which to shield funds.
/// - Parameter shieldingThreshold: the minimum transparent balance required before a proposal will be created.
/// - Parameter memoBytes: an optional memo to include as part of the proposal's transactions.
/// - Parameter transparentReceiver: a specific transparent receiver within the account
@ -51,7 +51,7 @@ protocol TransactionEncoder {
/// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
/// `SynchronizerErrors.notPrepared`.
func proposeShielding(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
shieldingThreshold: Zatoshi,
memoBytes: MemoBytes?,
transparentReceiver: String?
@ -78,18 +78,22 @@ protocol TransactionEncoder {
///
/// - Parameters:
/// - Parameter uri: a valid ZIP-321 payment URI.
/// - Parameter accountIndex: the ZIP 32 index of the account the proposal should be made from.
/// - Parameter accountUUID: the account the proposal should be made from.
/// - Throws:
/// - `walletTransEncoderCreateTransactionMissingSaplingParams` if the sapling parameters aren't downloaded.
/// - Some `ZcashError.rust*` if the creation of transaction fails.
func proposeFulfillingPaymentFromURI(
_ uri: String,
accountIndex: Zip32AccountIndex
accountUUID: AccountUUID
) async throws -> Proposal
/// submits a transaction to the Zcash peer-to-peer network.
/// - Parameter transaction: a transaction overview
func submit(transaction: EncodedTransaction) async throws
/// Tries to fetch the transaction for the given transaction ids.
/// - Parameter txIds: an array of transaction ids to be fetched from the DB.
func fetchTransactionsForTxIds(_ txIds: [Data]) async throws -> [ZcashTransaction.Overview]
func closeDBConnection()
}

16
Sources/ZcashLightClientKit/Transaction/WalletTransactionEncoder.swift
View File

@ -56,13 +56,13 @@ class WalletTransactionEncoder: TransactionEncoder {
}
func proposeTransfer(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
recipient: String,
amount: Zatoshi,
memoBytes: MemoBytes?
) async throws -> Proposal {
let proposal = try await rustBackend.proposeTransfer(
accountIndex: accountIndex,
accountUUID: accountUUID,
to: recipient,
value: amount.amount,
memo: memoBytes
@ -72,13 +72,13 @@ class WalletTransactionEncoder: TransactionEncoder {
}
func proposeShielding(
accountIndex: Zip32AccountIndex,
accountUUID: AccountUUID,
shieldingThreshold: Zatoshi,
memoBytes: MemoBytes?,
transparentReceiver: String? = nil
) async throws -> Proposal? {
guard let proposal = try await rustBackend.proposeShielding(
accountIndex: accountIndex,
accountUUID: accountUUID,
memo: memoBytes,
shieldingThreshold: shieldingThreshold,
transparentReceiver: transparentReceiver
@ -89,11 +89,11 @@ class WalletTransactionEncoder: TransactionEncoder {
func proposeFulfillingPaymentFromURI(
_ uri: String,
accountIndex: Zip32AccountIndex
accountUUID: AccountUUID
) async throws -> Proposal {
let proposal = try await rustBackend.proposeTransferFromURI(
uri,
accountIndex: accountIndex
accountUUID: accountUUID
)
return Proposal(inner: proposal)
}
@ -111,6 +111,10 @@ class WalletTransactionEncoder: TransactionEncoder {
usk: spendingKey
)
return try await fetchTransactionsForTxIds(txIds)
}
func fetchTransactionsForTxIds(_ txIds: [Data]) async throws -> [ZcashTransaction.Overview] {
logger.debug("transaction ids: \(txIds)")
var txs: [ZcashTransaction.Overview] = []

135
Tests/DarksideTests/AdvancedReOrgTests.swift
View File

@ -86,7 +86,7 @@ class AdvancedReOrgTests: ZcashTestCase {
var initialTotalBalance = Zatoshi(-1)
var initialVerifiedBalance = Zatoshi(-1)
self.expectedReorgHeight = receivedTxHeight + 1
let accountIndex = Zip32AccountIndex(0)
let accountUUID = TestsData.mockedAccountUUID
/*
precondition:know balances before tx at received_Tx_height arrives
@ -101,8 +101,8 @@ class AdvancedReOrgTests: ZcashTestCase {
try await coordinator.sync(
completion: { synchro in
synchronizer = synchro
initialVerifiedBalance = try await synchro.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
initialTotalBalance = try await synchro.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
initialVerifiedBalance = try await synchro.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
initialTotalBalance = try await synchro.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
preTxExpectation.fulfill()
shouldContinue = true
},
@ -136,8 +136,8 @@ class AdvancedReOrgTests: ZcashTestCase {
try await coordinator.sync(
completion: { synchro in
synchronizer = synchro
receivedTxVerifiedBalance = try await synchro.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
receivedTxTotalBalance = try await synchro.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
receivedTxVerifiedBalance = try await synchro.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
receivedTxTotalBalance = try await synchro.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
receivedTxExpectation.fulfill()
}, error: self.handleError
)
@ -203,8 +203,8 @@ class AdvancedReOrgTests: ZcashTestCase {
do {
try await coordinator.sync(
completion: { synchronizer in
afterReorgTxTotalBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
afterReorgTxVerifiedBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
afterReorgTxTotalBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
afterReorgTxVerifiedBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
reorgSyncexpectation.fulfill()
},
error: self.handleError
@ -239,8 +239,8 @@ class AdvancedReOrgTests: ZcashTestCase {
do {
try await coordinator.sync(
completion: { synchronizer in
finalReorgTxTotalBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
finalReorgTxVerifiedBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
finalReorgTxTotalBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
finalReorgTxVerifiedBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
finalsyncExpectation.fulfill()
},
error: self.handleError
@ -286,11 +286,12 @@ class AdvancedReOrgTests: ZcashTestCase {
/// 11. verify that the sent tx is mined and balance is correct
/// 12. applyStaged(sentTx + 10)
/// 13. verify that there's no more pending transaction
func testReorgChangesOutboundTxIndex() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testReorgChangesOutboundTxIndex() async throws {
try FakeChainBuilder.buildChain(darksideWallet: self.coordinator.service, branchID: branchID, chainName: chainName)
let receivedTxHeight: BlockHeight = 663188
var initialTotalBalance = Zatoshi(-1)
let accountIndex = Zip32AccountIndex(0)
let accountUUID = TestsData.mockedAccountUUID
/*
2. applyStaged(received_Tx_height)
@ -306,7 +307,7 @@ class AdvancedReOrgTests: ZcashTestCase {
do {
try await coordinator.sync(
completion: { synchronizer in
initialTotalBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
initialTotalBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
preTxExpectation.fulfill()
},
error: self.handleError
@ -326,13 +327,13 @@ class AdvancedReOrgTests: ZcashTestCase {
4. create transaction
*/
do {
let pendingTx = try await coordinator.synchronizer.sendToAddress(
spendingKey: coordinator.spendingKey,
zatoshi: sendAmount,
toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
memo: try Memo(string: "test transaction")
)
pendingEntity = pendingTx
// let pendingTx = try await coordinator.synchronizer.sendToAddress(
// spendingKey: coordinator.spendingKey,
// zatoshi: sendAmount,
// toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
// memo: try Memo(string: "test transaction")
// )
// pendingEntity = pendingTx
sendExpectation.fulfill()
} catch {
testError = error
@ -452,18 +453,18 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [lastSyncExpectation], timeout: 5)
let expectedVerifiedBalance = initialTotalBalance + pendingTx.value
let currentVerifiedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
let currentVerifiedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
// TODO: [#1247] needs to review this to properly solve, https://github.com/zcash/ZcashLightClientKit/issues/1247
// let expectedPendingTransactionsCount = await coordinator.synchronizer.pendingTransactions.count
// XCTAssertEqual(expectedPendingTransactionsCount, 0)
XCTAssertEqual(expectedVerifiedBalance, currentVerifiedBalance)
let resultingBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
let resultingBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
XCTAssertEqual(resultingBalance, currentVerifiedBalance)
}
func testIncomingTransactionIndexChange() async throws {
let accountIndex = Zip32AccountIndex(0)
let accountUUID = TestsData.mockedAccountUUID
await hookToReOrgNotification()
self.expectedReorgHeight = 663196
self.expectedRewindHeight = 663175
@ -483,8 +484,8 @@ class AdvancedReOrgTests: ZcashTestCase {
var preReorgVerifiedBalance = Zatoshi.zero
try await coordinator.sync(
completion: { synchronizer in
preReorgTotalBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
preReorgVerifiedBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
preReorgTotalBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
preReorgVerifiedBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
firstSyncExpectation.fulfill()
},
error: self.handleError
@ -506,8 +507,8 @@ class AdvancedReOrgTests: ZcashTestCase {
var postReorgVerifiedBalance = Zatoshi.zero
try await coordinator.sync(
completion: { synchronizer in
postReorgTotalBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
postReorgVerifiedBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
postReorgTotalBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
postReorgVerifiedBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
afterReorgSync.fulfill()
},
error: self.handleError
@ -520,7 +521,7 @@ class AdvancedReOrgTests: ZcashTestCase {
}
func testReOrgExpiresInboundTransaction() async throws {
let accountIndex = Zip32AccountIndex(0)
let accountUUID = TestsData.mockedAccountUUID
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
let receivedTxHeight = BlockHeight(663188)
try coordinator.applyStaged(blockheight: receivedTxHeight - 1)
@ -531,8 +532,8 @@ class AdvancedReOrgTests: ZcashTestCase {
try await coordinator.sync(
completion: { synchronizer in
initialBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
initialVerifiedBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
initialBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
initialVerifiedBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
expectation.fulfill()
},
error: self.handleError
@ -550,8 +551,8 @@ class AdvancedReOrgTests: ZcashTestCase {
try await coordinator.sync(
completion: { synchronizer in
afterTxBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
afterTxVerifiedBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
afterTxBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
afterTxVerifiedBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
let receivedTransactions = await synchronizer.receivedTransactions
XCTAssertNotNil(
receivedTransactions.first { $0.minedHeight == receivedTxHeight },
@ -580,8 +581,8 @@ class AdvancedReOrgTests: ZcashTestCase {
try await coordinator.sync(
completion: { synchronizer in
afterReOrgBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
afterReOrgVerifiedBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
afterReOrgBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
afterReOrgVerifiedBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
let receivedTransactions = await synchronizer.receivedTransactions
XCTAssertNil(
receivedTransactions.first { $0.minedHeight == receivedTxHeight },
@ -615,7 +616,7 @@ class AdvancedReOrgTests: ZcashTestCase {
let output = transactionOutputs[0]
XCTAssertEqual(output.recipient, .internalAccount(0))
XCTAssertEqual(output.recipient, .internalAccount(TestsData.mockedAccountUUID))
XCTAssertEqual(output.value, Zatoshi(100000))
}
@ -632,7 +633,7 @@ class AdvancedReOrgTests: ZcashTestCase {
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
let incomingTxHeight = BlockHeight(663188)
let accountIndex = Zip32AccountIndex(0)
let accountUUID = TestsData.mockedAccountUUID
try coordinator.applyStaged(blockheight: incomingTxHeight + 1)
@ -658,7 +659,7 @@ class AdvancedReOrgTests: ZcashTestCase {
/*
1a. save balances
*/
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
initialBalance = accountBalance?.saplingBalance.total() ?? .zero
initialVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
incomingTx = await coordinator.synchronizer.receivedTransactions.first(where: { $0.minedHeight == incomingTxHeight })
@ -707,7 +708,7 @@ class AdvancedReOrgTests: ZcashTestCase {
/*
7. check that balances still match
*/
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedVerifiedBalance, initialVerifiedBalance)
@ -717,7 +718,7 @@ class AdvancedReOrgTests: ZcashTestCase {
func testTxIndexReorg() async throws {
try coordinator.resetBlocks(dataset: .predefined(dataset: .txIndexChangeBefore))
let accountIndex = Zip32AccountIndex(0)
let accountUUID = TestsData.mockedAccountUUID
let txReorgHeight = BlockHeight(663195)
let finalHeight = BlockHeight(663200)
try coordinator.applyStaged(blockheight: txReorgHeight)
@ -729,8 +730,8 @@ class AdvancedReOrgTests: ZcashTestCase {
try await coordinator.sync(
completion: { synchronizer in
initialBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
initialVerifiedBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
initialBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
initialVerifiedBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
firstSyncExpectation.fulfill()
},
error: self.handleError
@ -754,7 +755,7 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [lastSyncExpectation], timeout: 5)
let accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
let accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, initialBalance)
@ -784,7 +785,8 @@ class AdvancedReOrgTests: ZcashTestCase {
/// 13. apply height(sentTxHeight + 15)
/// 14. sync to latest height
/// 15. verify that there's no pending transaction and that the tx is displayed on the sentTransactions collection
func testReOrgChangesOutboundTxMinedHeight() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testReOrgChangesOutboundTxMinedHeight() async throws {
await hookToReOrgNotification()
/*
@ -824,13 +826,13 @@ class AdvancedReOrgTests: ZcashTestCase {
let recipient = try Recipient(Environment.testRecipientAddress, network: self.network.networkType)
do {
let pendingTx = try await coordinator.synchronizer.sendToAddress(
spendingKey: self.coordinator.spendingKey,
zatoshi: Zatoshi(20000),
toAddress: recipient,
memo: try Memo(string: "this is a test")
)
pendingEntity = pendingTx
// let pendingTx = try await coordinator.synchronizer.sendToAddress(
// spendingKey: self.coordinator.spendingKey,
// zatoshi: Zatoshi(20000),
// toAddress: recipient,
// memo: try Memo(string: "this is a test")
// )
// pendingEntity = pendingTx
sendExpectation.fulfill()
} catch {
await handleError(error)
@ -1068,7 +1070,7 @@ class AdvancedReOrgTests: ZcashTestCase {
branchID: branchID,
chainName: chainName
)
let accountIndex = Zip32AccountIndex(0)
let accountUUID = TestsData.mockedAccountUUID
sleep(2)
try coordinator.resetBlocks(dataset: .predefined(dataset: .txHeightReOrgBefore))
@ -1088,7 +1090,7 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 5)
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let initialBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
let initialVerifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
guard let initialTxHeight = try await coordinator.synchronizer.allReceivedTransactions().first?.minedHeight else {
@ -1119,7 +1121,7 @@ class AdvancedReOrgTests: ZcashTestCase {
return
}
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(initialVerifiedBalance, expectedVerifiedBalance)
@ -1149,7 +1151,7 @@ class AdvancedReOrgTests: ZcashTestCase {
try coordinator.resetBlocks(dataset: .predefined(dataset: .txReOrgRemovesInboundTxBefore))
let accountIndex = Zip32AccountIndex(0)
let accountUUID = TestsData.mockedAccountUUID
let reorgHeight: BlockHeight = 663195
self.expectedReorgHeight = reorgHeight
self.expectedRewindHeight = reorgHeight - 10
@ -1171,7 +1173,7 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 5)
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let initialTotalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
let initialVerifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
@ -1210,7 +1212,7 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [afterReorgSyncExpectation], timeout: 5)
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(initialVerifiedBalance, expectedVerifiedBalance)
@ -1230,7 +1232,8 @@ class AdvancedReOrgTests: ZcashTestCase {
/// 7. stage 15 blocks from sentTxHeigth to cause a reorg
/// 8. sync to latest height
/// 9. verify that there's an expired transaction as a pending transaction
func testReOrgRemovesOutboundTxAndIsNeverMined() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testReOrgRemovesOutboundTxAndIsNeverMined() async throws {
await hookToReOrgNotification()
/*
@ -1239,7 +1242,7 @@ class AdvancedReOrgTests: ZcashTestCase {
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
let sentTxHeight: BlockHeight = 663195
try coordinator.applyStaged(blockheight: sentTxHeight - 1)
let accountIndex = Zip32AccountIndex(0)
let accountUUID = TestsData.mockedAccountUUID
sleep(2)
@ -1262,7 +1265,7 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 10)
sleep(1)
let initialTotalBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
let initialTotalBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
let sendExpectation = XCTestExpectation(description: "send expectation")
var pendingEntity: ZcashTransaction.Overview?
@ -1271,13 +1274,13 @@ class AdvancedReOrgTests: ZcashTestCase {
2. send transaction to recipient address
*/
do {
let pendingTx = try await coordinator.synchronizer.sendToAddress(
spendingKey: self.coordinator.spendingKey,
zatoshi: Zatoshi(20000),
toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
memo: try! Memo(string: "this is a test")
)
pendingEntity = pendingTx
//// let pendingTx = try await coordinator.synchronizer.sendToAddress(
//// spendingKey: self.coordinator.spendingKey,
//// zatoshi: Zatoshi(20000),
//// toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
//// memo: try! Memo(string: "this is a test")
// )
// pendingEntity = pendingTx
sendExpectation.fulfill()
} catch {
await handleError(error)
@ -1382,7 +1385,7 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [lastSyncExpectation], timeout: 5)
let expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
let expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, initialTotalBalance)
}

225
Tests/DarksideTests/BalanceTests.swift
View File

@ -55,7 +55,8 @@ class BalanceTests: ZcashTestCase {
/**
verify that when sending the maximum amount, the transactions are broadcasted properly
*/
func testMaxAmountSendBroadcast() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testMaxAmountSendBroadcast() async throws {
let notificationHandler = SDKSynchonizerListener()
let foundTransactionsExpectation = XCTestExpectation(description: "found transactions expectation")
let transactionMinedExpectation = XCTestExpectation(description: "transaction mined expectation")
@ -84,8 +85,8 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 12)
// 2 check that there are no unconfirmed funds
let accountIndex = Zip32AccountIndex(0)
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
let accountUUID = TestsData.mockedAccountUUID
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
@ -99,13 +100,13 @@ class BalanceTests: ZcashTestCase {
var pendingTx: ZcashTransaction.Overview?
do {
let transaction = try await coordinator.synchronizer.sendToAddress(
spendingKey: spendingKey,
zatoshi: maxBalance,
toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
memo: try Memo(string: "this is a test")
)
pendingTx = transaction
// let transaction = try await coordinator.synchronizer.sendToAddress(
// spendingKey: spendingKey,
// zatoshi: maxBalance,
// toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
// memo: try Memo(string: "this is a test")
// )
// pendingTx = transaction
self.sentTransactionExpectation.fulfill()
} catch {
XCTFail("sendToAddress failed: \(error)")
@ -200,7 +201,7 @@ class BalanceTests: ZcashTestCase {
//
// XCTAssertNil(confirmedPending, "pending, now confirmed transaction found")
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, .zero)
@ -210,7 +211,8 @@ class BalanceTests: ZcashTestCase {
/**
verify that when sending the maximum amount of zatoshi, the transactions are broadcasted properly
*/
func testMaxAmountSend() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testMaxAmountSend() async throws {
let notificationHandler = SDKSynchonizerListener()
let foundTransactionsExpectation = XCTestExpectation(description: "found transactions expectation")
let transactionMinedExpectation = XCTestExpectation(description: "transaction mined expectation")
@ -239,8 +241,8 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 12)
// 2 check that there are no unconfirmed funds
let accountIndex = Zip32AccountIndex(0)
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
let accountUUID = TestsData.mockedAccountUUID
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
@ -253,13 +255,13 @@ class BalanceTests: ZcashTestCase {
let spendingKey = coordinator.spendingKey
var pendingTx: ZcashTransaction.Overview?
do {
let transaction = try await coordinator.synchronizer.sendToAddress(
spendingKey: spendingKey,
zatoshi: maxBalanceMinusOne,
toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
memo: try Memo(string: "\(self.description) \(Date().description)")
)
pendingTx = transaction
// let transaction = try await coordinator.synchronizer.sendToAddress(
// spendingKey: spendingKey,
// zatoshi: maxBalanceMinusOne,
// toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
// memo: try Memo(string: "\(self.description) \(Date().description)")
// )
// pendingTx = transaction
self.sentTransactionExpectation.fulfill()
} catch {
XCTFail("sendToAddress failed: \(error)")
@ -356,7 +358,7 @@ class BalanceTests: ZcashTestCase {
//
// XCTAssertNil(confirmedPending, "pending, now confirmed transaction found")
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, .zero)
@ -366,7 +368,8 @@ class BalanceTests: ZcashTestCase {
/**
verify that when sending the maximum amount minus one zatoshi, the transactions are broadcasted properly
*/
func testMaxAmountMinusOneSendFails() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testMaxAmountMinusOneSendFails() async throws {
// 1 sync and get spendable funds
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
@ -389,8 +392,8 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 12)
// 2 check that there are no unconfirmed funds
let accountIndex = Zip32AccountIndex(0)
let accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
let accountUUID = TestsData.mockedAccountUUID
let accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
@ -403,12 +406,12 @@ class BalanceTests: ZcashTestCase {
let spendingKey = coordinator.spendingKey
do {
_ = try await coordinator.synchronizer.sendToAddress(
spendingKey: spendingKey,
zatoshi: maxBalanceMinusOne,
toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
memo: try Memo(string: "\(self.description) \(Date().description)")
)
// _ = try await coordinator.synchronizer.sendToAddress(
// spendingKey: spendingKey,
// zatoshi: maxBalanceMinusOne,
// toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
// memo: try Memo(string: "\(self.description) \(Date().description)")
// )
} catch {
guard
let zcashError = error as? ZcashError,
@ -427,7 +430,8 @@ class BalanceTests: ZcashTestCase {
/**
verify that when sending the a no change transaction, the transactions are broadcasted properly
*/
func testSingleNoteNoChangeTransaction() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testSingleNoteNoChangeTransaction() async throws {
let notificationHandler = SDKSynchonizerListener()
let foundTransactionsExpectation = XCTestExpectation(description: "found transactions expectation")
let transactionMinedExpectation = XCTestExpectation(description: "transaction mined expectation")
@ -456,8 +460,8 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 12)
// 2 check that there are no unconfirmed funds
let accountIndex = Zip32AccountIndex(0)
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
let accountUUID = TestsData.mockedAccountUUID
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
@ -470,13 +474,13 @@ class BalanceTests: ZcashTestCase {
let spendingKey = coordinator.spendingKey
var pendingTx: ZcashTransaction.Overview?
do {
let transaction = try await coordinator.synchronizer.sendToAddress(
spendingKey: spendingKey,
zatoshi: maxBalanceMinusFee,
toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
memo: try Memo(string: "test send \(self.description) \(Date().description)")
)
pendingTx = transaction
// let transaction = try await coordinator.synchronizer.sendToAddress(
// spendingKey: spendingKey,
// zatoshi: maxBalanceMinusFee,
// toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
// memo: try Memo(string: "test send \(self.description) \(Date().description)")
// )
// pendingTx = transaction
self.sentTransactionExpectation.fulfill()
} catch {
XCTFail("sendToAddress failed: \(error)")
@ -573,7 +577,7 @@ class BalanceTests: ZcashTestCase {
//
// XCTAssertNil(confirmedPending, "pending, now confirmed transaction found")
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, Zatoshi(100000))
@ -619,8 +623,8 @@ class BalanceTests: ZcashTestCase {
let spendingKey = coordinator.spendingKey
let accountIndex = Zip32AccountIndex(0)
let presendVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
let accountUUID = TestsData.mockedAccountUUID
let presendVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
/*
there's more zatoshi to send than network fee
@ -629,16 +633,16 @@ class BalanceTests: ZcashTestCase {
var pendingTx: ZcashTransaction.Overview?
let transaction = try await coordinator.synchronizer.sendToAddress(
spendingKey: spendingKey,
zatoshi: sendAmount,
toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
memo: try Memo(string: "this is a test")
)
pendingTx = transaction
// let transaction = try await coordinator.synchronizer.sendToAddress(
// spendingKey: spendingKey,
// zatoshi: sendAmount,
// toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
// memo: try Memo(string: "this is a test")
// )
// pendingTx = transaction
self.sentTransactionExpectation.fulfill()
var expectedVerifiedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
var expectedVerifiedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
XCTAssertTrue(expectedVerifiedBalance > .zero)
await fulfillment(of: [sentTransactionExpectation], timeout: 12)
@ -671,7 +675,7 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [mineExpectation], timeout: 5)
let accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
let accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
@ -722,7 +726,7 @@ class BalanceTests: ZcashTestCase {
spentValue: sentOutput.value,
fee: fee,
sentAmount: self.sendAmount,
currentVerifiedBalance: try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
currentVerifiedBalance: try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
)
}
@ -764,8 +768,8 @@ class BalanceTests: ZcashTestCase {
let spendingKey = coordinator.spendingKey
let accountIndex = Zip32AccountIndex(0)
let presendBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
let accountUUID = TestsData.mockedAccountUUID
let presendBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
// there's more zatoshi to send than network fee
XCTAssertTrue(presendBalance >= network.constants.defaultFee() + sendAmount)
@ -773,13 +777,13 @@ class BalanceTests: ZcashTestCase {
var testError: Error?
do {
let transaction = try await coordinator.synchronizer.sendToAddress(
spendingKey: spendingKey,
zatoshi: sendAmount,
toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
memo: try Memo(string: "test send \(self.description) \(Date().description)")
)
pendingTx = transaction
// let transaction = try await coordinator.synchronizer.sendToAddress(
// spendingKey: spendingKey,
// zatoshi: sendAmount,
// toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
// memo: try Memo(string: "test send \(self.description) \(Date().description)")
// )
// pendingTx = transaction
self.sentTransactionExpectation.fulfill()
} catch {
// balance should be the same as before sending if transaction failed
@ -787,7 +791,7 @@ class BalanceTests: ZcashTestCase {
XCTFail("sendToAddress failed: \(error)")
}
let accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
let accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
var expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
XCTAssertTrue(expectedVerifiedBalance > .zero)
await fulfillment(of: [sentTransactionExpectation], timeout: 12)
@ -837,7 +841,7 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [mineExpectation], timeout: 5)
expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
XCTAssertEqual(
presendBalance - self.sendAmount - network.constants.defaultFee(),
expectedBalance
@ -873,9 +877,9 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [syncedExpectation], timeout: 5)
let accountIndex = Zip32AccountIndex(0)
let accountUUID = TestsData.mockedAccountUUID
let clearedTransactions = await coordinator.synchronizer.transactions
let expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
let expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
XCTAssertEqual(clearedTransactions.count, 2)
XCTAssertEqual(expectedBalance, Zatoshi(200000))
}
@ -902,7 +906,9 @@ class BalanceTests: ZcashTestCase {
There’s a change note of value (previous note value - sent amount)
*/
func testVerifyChangeTransaction() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testVerifyChangeTransaction() async throws {
try FakeChainBuilder.buildSingleNoteChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
try coordinator.applyStaged(blockheight: defaultLatestHeight)
@ -927,8 +933,8 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [syncedExpectation], timeout: 6)
let accountIndex = Zip32AccountIndex(0)
let accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
let accountUUID = TestsData.mockedAccountUUID
let accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let previousVerifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let previousTotalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
@ -940,13 +946,13 @@ class BalanceTests: ZcashTestCase {
let memo = try Memo(string: "shielding is fun!")
var pendingTx: ZcashTransaction.Overview?
let transaction = try await coordinator.synchronizer.sendToAddress(
spendingKey: spendingKey,
zatoshi: sendAmount,
toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
memo: memo
)
pendingTx = transaction
// let transaction = try await coordinator.synchronizer.sendToAddress(
// spendingKey: spendingKey,
// zatoshi: sendAmount,
// toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
// memo: memo
// )
// pendingTx = transaction
sendExpectation.fulfill()
await fulfillment(of: [sendExpectation], timeout: 30)
@ -1025,26 +1031,26 @@ class BalanceTests: ZcashTestCase {
changeOutput.value
)
guard let fee = transaction.fee else {
XCTFail("sent transaction has no fee")
return
}
/*
Balance meets verified Balance and total balance criteria
*/
self.verifiedBalanceValidation(
previousBalance: previousVerifiedBalance,
spentValue: sentOutput.value,
fee: fee,
sentAmount: self.sendAmount,
currentVerifiedBalance: try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
)
self.totalBalanceValidation(
totalBalance: try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero,
previousTotalbalance: previousTotalBalance,
sentAmount: self.sendAmount
)
// guard let fee = transaction.fee else {
// XCTFail("sent transaction has no fee")
// return
// }
// /*
// Balance meets verified Balance and total balance criteria
// */
// self.verifiedBalanceValidation(
// previousBalance: previousVerifiedBalance,
// spentValue: sentOutput.value,
// fee: fee,
// sentAmount: self.sendAmount,
// currentVerifiedBalance: try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
// )
//
// self.totalBalanceValidation(
// totalBalance: try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero,
// previousTotalbalance: previousTotalBalance,
// sentAmount: self.sendAmount
// )
syncToMinedheightExpectation.fulfill()
},
@ -1079,7 +1085,8 @@ class BalanceTests: ZcashTestCase {
Total Balance is equal to total balance previously shown before sending the expired transaction
Verified Balance is equal to verified balance previously shown before sending the expired transaction
*/
func testVerifyBalanceAfterExpiredTransaction() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testVerifyBalanceAfterExpiredTransaction() async throws {
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
try coordinator.applyStaged(blockheight: self.defaultLatestHeight + 10)
@ -1100,24 +1107,24 @@ class BalanceTests: ZcashTestCase {
let spendingKey = coordinator.spendingKey
let accountIndex = Zip32AccountIndex(0)
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
let accountUUID = TestsData.mockedAccountUUID
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let previousVerifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let previousTotalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
let sendExpectation = XCTestExpectation(description: "send expectation")
var pendingTx: ZcashTransaction.Overview?
do {
let pending = try await coordinator.synchronizer.sendToAddress(
spendingKey: spendingKey,
zatoshi: sendAmount,
toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
memo: try Memo(string: "test send \(self.description)")
)
pendingTx = pending
// let pending = try await coordinator.synchronizer.sendToAddress(
// spendingKey: spendingKey,
// zatoshi: sendAmount,
// toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
// memo: try Memo(string: "test send \(self.description)")
// )
// pendingTx = pending
sendExpectation.fulfill()
} catch {
// balance should be the same as before sending if transaction failed
let accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
let accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedVerifiedBalance, previousVerifiedBalance)
@ -1151,7 +1158,7 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [expirationSyncExpectation], timeout: 5)
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
/*

4
Tests/DarksideTests/PaymentURIFulfillmentTests.swift
View File

@ -113,7 +113,7 @@ class PaymentURIFulfillmentTests: ZcashTestCase {
do {
let proposal = try await coordinator.synchronizer.proposefulfillingPaymentURI(
paymentURI,
accountIndex: Zip32AccountIndex(0)
accountUUID: TestsData.mockedAccountUUID
)
let transactions = try await coordinator.synchronizer.createProposedTransactions(
@ -320,7 +320,7 @@ class PaymentURIFulfillmentTests: ZcashTestCase {
do {
_ = try await coordinator.synchronizer.proposefulfillingPaymentURI(
paymentURI,
accountIndex: Zip32AccountIndex(0)
accountUUID: TestsData.mockedAccountUUID
)
XCTFail("`fulfillPaymentURI` should have failed")

17
Tests/DarksideTests/PendingTransactionUpdatesTest.swift
View File

@ -50,7 +50,8 @@ class PendingTransactionUpdatesTest: ZcashTestCase {
try? FileManager.default.removeItem(at: coordinator.databases.dataDB)
}
func testPendingTransactionMinedHeightUpdated() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testPendingTransactionMinedHeightUpdated() async throws {
/*
1. create fake chain
*/
@ -89,13 +90,13 @@ class PendingTransactionUpdatesTest: ZcashTestCase {
*/
LoggerProxy.info("2. send transaction to recipient address")
do {
let pendingTx = try await coordinator.synchronizer.sendToAddress(
spendingKey: self.coordinator.spendingKey,
zatoshi: Zatoshi(20000),
toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
memo: try Memo(string: "this is a test")
)
pendingEntity = pendingTx
// let pendingTx = try await coordinator.synchronizer.sendToAddress(
// spendingKey: self.coordinator.spendingKey,
// zatoshi: Zatoshi(20000),
// toAddress: try Recipient(Environment.testRecipientAddress, network: self.network.networkType),
// memo: try Memo(string: "this is a test")
// )
// pendingEntity = pendingTx
sendExpectation.fulfill()
} catch {
await self.handleError(error)

66
Tests/DarksideTests/RewindRescanTests.swift
View File

@ -69,9 +69,9 @@ class RewindRescanTests: ZcashTestCase {
// 1 sync and get spendable funds
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
let accountIndex = Zip32AccountIndex(0)
let accountUUID = TestsData.mockedAccountUUID
try coordinator.applyStaged(blockheight: defaultLatestHeight + 50)
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let initialVerifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let initialTotalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
sleep(1)
@ -89,7 +89,7 @@ class RewindRescanTests: ZcashTestCase {
}
await fulfillment(of: [firstSyncExpectation], timeout: 12)
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
// 2 check that there are no unconfirmed funds
@ -126,7 +126,7 @@ class RewindRescanTests: ZcashTestCase {
// XCTAssertEqual(lastScannedHeight, self.birthday)
// check that the balance is cleared
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
var expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
var expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(initialVerifiedBalance, expectedVerifiedBalance)
@ -147,7 +147,7 @@ class RewindRescanTests: ZcashTestCase {
await fulfillment(of: [secondScanExpectation], timeout: 12)
// verify that the balance still adds up
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(verifiedBalance, expectedVerifiedBalance)
@ -155,7 +155,8 @@ class RewindRescanTests: ZcashTestCase {
}
// FIXME [#789]: Fix test
func testRescanToHeight() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testRescanToHeight() async throws {
// 1 sync and get spendable funds
try FakeChainBuilder.buildChainWithTxsFarFromEachOther(
darksideWallet: coordinator.service,
@ -164,11 +165,11 @@ class RewindRescanTests: ZcashTestCase {
length: 10000
)
let accountIndex = Zip32AccountIndex(0)
let accountUUID = TestsData.mockedAccountUUID
let newChaintTip = defaultLatestHeight + 10000
try coordinator.applyStaged(blockheight: newChaintTip)
sleep(3)
let initialVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
let initialVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
let firstSyncExpectation = XCTestExpectation(description: "first sync expectation")
do {
@ -183,7 +184,7 @@ class RewindRescanTests: ZcashTestCase {
}
await fulfillment(of: [firstSyncExpectation], timeout: 20)
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
// 2 check that there are no unconfirmed funds
@ -217,7 +218,7 @@ class RewindRescanTests: ZcashTestCase {
await fulfillment(of: [rewindExpectation], timeout: 2)
// check that the balance is cleared
var expectedVerifiedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
var expectedVerifiedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
XCTAssertEqual(initialVerifiedBalance, expectedVerifiedBalance)
let secondScanExpectation = XCTestExpectation(description: "rescan")
@ -236,7 +237,7 @@ class RewindRescanTests: ZcashTestCase {
await fulfillment(of: [secondScanExpectation], timeout: 20)
// verify that the balance still adds up
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(verifiedBalance, expectedVerifiedBalance)
@ -245,13 +246,13 @@ class RewindRescanTests: ZcashTestCase {
// try to spend the funds
let sendExpectation = XCTestExpectation(description: "after rewind expectation")
do {
let pendingTx = try await coordinator.synchronizer.sendToAddress(
spendingKey: coordinator.spendingKey,
zatoshi: Zatoshi(1000),
toAddress: try! Recipient(Environment.testRecipientAddress, network: .mainnet),
memo: .empty
)
XCTAssertEqual(Zatoshi(1000), pendingTx.value)
// let pendingTx = try await coordinator.synchronizer.sendToAddress(
// spendingKey: coordinator.spendingKey,
// zatoshi: Zatoshi(1000),
// toAddress: try! Recipient(Environment.testRecipientAddress, network: .mainnet),
// memo: .empty
// )
// XCTAssertEqual(Zatoshi(1000), pendingTx.value)
sendExpectation.fulfill()
} catch {
XCTFail("sending fail: \(error)")
@ -276,8 +277,8 @@ class RewindRescanTests: ZcashTestCase {
)
await fulfillment(of: [firstSyncExpectation], timeout: 12)
let accountIndex = Zip32AccountIndex(0)
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
let accountUUID = TestsData.mockedAccountUUID
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
// 2 check that there are no unconfirmed funds
@ -331,7 +332,7 @@ class RewindRescanTests: ZcashTestCase {
await fulfillment(of: [secondScanExpectation], timeout: 12)
// verify that the balance still adds up
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(verifiedBalance, expectedVerifiedBalance)
@ -339,7 +340,8 @@ class RewindRescanTests: ZcashTestCase {
}
// FIXME [#791]: Fix test
func testRewindAfterSendingTransaction() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testRewindAfterSendingTransaction() async throws {
let notificationHandler = SDKSynchonizerListener()
let foundTransactionsExpectation = XCTestExpectation(description: "found transactions expectation")
let transactionMinedExpectation = XCTestExpectation(description: "transaction mined expectation")
@ -368,8 +370,8 @@ class RewindRescanTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 12)
// 2 check that there are no unconfirmed funds
let accountIndex = Zip32AccountIndex(0)
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
let accountUUID = TestsData.mockedAccountUUID
var accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
@ -382,13 +384,13 @@ class RewindRescanTests: ZcashTestCase {
let spendingKey = coordinator.spendingKey
var pendingTx: ZcashTransaction.Overview?
do {
let transaction = try await coordinator.synchronizer.sendToAddress(
spendingKey: spendingKey,
zatoshi: maxBalance,
toAddress: try! Recipient(Environment.testRecipientAddress, network: .mainnet),
memo: try Memo(string: "test send \(self.description) \(Date().description)")
)
pendingTx = transaction
// let transaction = try await coordinator.synchronizer.sendToAddress(
// spendingKey: spendingKey,
// zatoshi: maxBalance,
// toAddress: try! Recipient(Environment.testRecipientAddress, network: .mainnet),
// memo: try Memo(string: "test send \(self.description) \(Date().description)")
// )
// pendingTx = transaction
self.sentTransactionExpectation.fulfill()
} catch {
XCTFail("sendToAddress failed: \(error)")
@ -525,7 +527,7 @@ class RewindRescanTests: ZcashTestCase {
//
// XCTAssertNil(confirmedPending, "pending, now confirmed transaction found")
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]
accountBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]
let expectedVerifiedbalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, .zero)

45
Tests/DarksideTests/ShieldFundsTests.swift
View File

@ -85,8 +85,9 @@ class ShieldFundsTests: ZcashTestCase {
/// 15. sync up to the new chain tip
/// verify that the shielded transactions are confirmed
///
func testShieldFunds() async throws {
let accountIndex = Zip32AccountIndex(0)
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testShieldFunds() async throws {
let accountUUID = TestsData.mockedAccountUUID
// 1. load the dataset
try coordinator.service.useDataset(from: "https://raw.githubusercontent.com/zcash-hackworks/darksidewalletd-test-data/master/shield-funds/1631000.txt")
@ -101,7 +102,7 @@ class ShieldFundsTests: ZcashTestCase {
var initialTotalBalance = Zatoshi(-1)
var initialVerifiedBalance = Zatoshi(-1)
var initialTransparentBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.unshielded ?? .zero
var initialTransparentBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.unshielded ?? .zero
let utxo = try GetAddressUtxosReply(jsonString:
"""
@ -123,8 +124,8 @@ class ShieldFundsTests: ZcashTestCase {
do {
try await coordinator.sync(
completion: { synchronizer in
initialVerifiedBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
initialTotalBalance = try await synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
initialVerifiedBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
initialTotalBalance = try await synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
preTxExpectation.fulfill()
shouldContinue = true
},
@ -144,7 +145,7 @@ class ShieldFundsTests: ZcashTestCase {
// at this point the balance should be all zeroes for transparent and shielded funds
XCTAssertEqual(initialTotalBalance, Zatoshi.zero)
XCTAssertEqual(initialVerifiedBalance, Zatoshi.zero)
initialTransparentBalance = (try? await coordinator.synchronizer.getAccountsBalances()[accountIndex])?.unshielded ?? .zero
initialTransparentBalance = (try? await coordinator.synchronizer.getAccountsBalances()[accountUUID])?.unshielded ?? .zero
XCTAssertEqual(initialTransparentBalance, .zero)
@ -177,7 +178,7 @@ class ShieldFundsTests: ZcashTestCase {
// at this point the balance should be zero for shielded, then zero verified transparent funds
// and 10000 zatoshi of total (not verified) transparent funds.
let tFundsDetectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.unshielded ?? .zero
let tFundsDetectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.unshielded ?? .zero
XCTAssertEqual(tFundsDetectedBalance, Zatoshi(10000))
@ -206,7 +207,7 @@ class ShieldFundsTests: ZcashTestCase {
await fulfillment(of: [tFundsConfirmationSyncExpectation], timeout: 5)
// the transparent funds should be 10000 zatoshis both total and verified
let confirmedTFundsBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.unshielded ?? .zero
let confirmedTFundsBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.unshielded ?? .zero
XCTAssertEqual(confirmedTFundsBalance, Zatoshi(10000))
@ -219,14 +220,14 @@ class ShieldFundsTests: ZcashTestCase {
// shield the funds
do {
let pendingTx = try await coordinator.synchronizer.shieldFunds(
spendingKey: coordinator.spendingKey,
memo: try Memo(string: "shield funds"),
shieldingThreshold: Zatoshi(10000)
)
shouldContinue = true
XCTAssertEqual(pendingTx.value, Zatoshi(10000) - pendingTx.fee!)
shieldingPendingTx = pendingTx
// let pendingTx = try await coordinator.synchronizer.shieldFunds(
// spendingKey: coordinator.spendingKey,
// memo: try Memo(string: "shield funds"),
// shieldingThreshold: Zatoshi(10000)
// )
// shouldContinue = true
// XCTAssertEqual(pendingTx.value, Zatoshi(10000) - pendingTx.fee!)
// shieldingPendingTx = pendingTx
shieldFundsExpectation.fulfill()
} catch {
shieldFundsExpectation.fulfill()
@ -237,13 +238,13 @@ class ShieldFundsTests: ZcashTestCase {
guard shouldContinue else { return }
let postShieldingBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.unshielded ?? .zero
let postShieldingBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.unshielded ?? .zero
// when funds are shielded the UTXOs should be marked as spend and not shown on the balance.
// now balance should be zero shielded, zero transaparent.
// verify that the balance has been marked as spent regardless of confirmation
// FIXME: [#720] this should be zero, https://github.com/zcash/ZcashLightClientKit/issues/720
XCTAssertEqual(postShieldingBalance, Zatoshi(10000))
var expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
var expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, .zero)
// 10. clear the UTXO from darksidewalletd's cache
@ -290,11 +291,11 @@ class ShieldFundsTests: ZcashTestCase {
// Now it should verify that the balance has been shielded. The resulting balance should be zero
// transparent funds and `10000 - fee` total shielded funds, zero verified shielded funds.
let postShieldingShieldedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.unshielded ?? .zero
let postShieldingShieldedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.unshielded ?? .zero
XCTAssertEqual(postShieldingShieldedBalance, .zero)
expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, Zatoshi(9000))
// 14. proceed confirm the shielded funds by staging ten more blocks
@ -330,9 +331,9 @@ class ShieldFundsTests: ZcashTestCase {
XCTAssertNotNil(clearedTransaction)
expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, Zatoshi(9000))
let postShieldingConfirmationShieldedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.unshielded ?? .zero
let postShieldingConfirmationShieldedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.unshielded ?? .zero
XCTAssertEqual(postShieldingConfirmationShieldedBalance, .zero)
}

28
Tests/DarksideTests/SynchronizerDarksideTests.swift
View File

@ -190,31 +190,31 @@ class SynchronizerDarksideTests: ZcashTestCase {
let expectedStates: [SynchronizerState] = [
SynchronizerState(
syncSessionID: .nullID,
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .unprepared,
latestBlockHeight: 0
),
SynchronizerState(
syncSessionID: uuids[0],
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .syncing(0),
latestBlockHeight: 0
),
SynchronizerState(
syncSessionID: uuids[0],
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .syncing(0.9),
latestBlockHeight: 663189
),
SynchronizerState(
syncSessionID: uuids[0],
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .syncing(1.0),
latestBlockHeight: 663189
),
SynchronizerState(
syncSessionID: uuids[0],
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .synced,
latestBlockHeight: 663189
)
@ -262,31 +262,31 @@ class SynchronizerDarksideTests: ZcashTestCase {
let expectedStates: [SynchronizerState] = [
SynchronizerState(
syncSessionID: .nullID,
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .unprepared,
latestBlockHeight: 0
),
SynchronizerState(
syncSessionID: uuids[0],
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .syncing(0),
latestBlockHeight: 0
),
SynchronizerState(
syncSessionID: uuids[0],
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .syncing(0.9),
latestBlockHeight: 663189
),
SynchronizerState(
syncSessionID: uuids[0],
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .syncing(1.0),
latestBlockHeight: 663189
),
SynchronizerState(
syncSessionID: uuids[0],
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .synced,
latestBlockHeight: 663189
)
@ -319,25 +319,25 @@ class SynchronizerDarksideTests: ZcashTestCase {
let secondBatchOfExpectedStates: [SynchronizerState] = [
SynchronizerState(
syncSessionID: uuids[1],
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .syncing(0),
latestBlockHeight: 663189
),
SynchronizerState(
syncSessionID: uuids[1],
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .syncing(0.9),
latestBlockHeight: 663200
),
SynchronizerState(
syncSessionID: uuids[1],
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .syncing(1.0),
latestBlockHeight: 663200
),
SynchronizerState(
syncSessionID: uuids[1],
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: .synced,
latestBlockHeight: 663200
)

14
Tests/DarksideTests/SynchronizerTests.swift
View File

@ -258,9 +258,9 @@ final class SynchronizerTests: ZcashTestCase {
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
try coordinator.applyStaged(blockheight: 663200)
let accountIndex = Zip32AccountIndex(0)
let initialVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
let initialTotalBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
let accountUUID = TestsData.mockedAccountUUID
let initialVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
let initialTotalBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
sleep(1)
let firstSyncExpectation = XCTestExpectation(description: "first sync expectation")
@ -277,8 +277,8 @@ final class SynchronizerTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 12)
let verifiedBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
let verifiedBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
// 2 check that there are no unconfirmed funds
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
XCTAssertEqual(verifiedBalance, totalBalance)
@ -333,8 +333,8 @@ final class SynchronizerTests: ZcashTestCase {
// XCTAssertEqual(lastScannedHeight, self.birthday)
// check that the balance is cleared
let expectedVerifiedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.spendableValue ?? .zero
let expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountIndex]?.saplingBalance.total() ?? .zero
let expectedVerifiedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.spendableValue ?? .zero
let expectedBalance = try await coordinator.synchronizer.getAccountsBalances()[accountUUID]?.saplingBalance.total() ?? .zero
XCTAssertEqual(initialVerifiedBalance, expectedVerifiedBalance)
XCTAssertEqual(initialTotalBalance, expectedBalance)
}

4
Tests/DarksideTests/TransactionEnhancementTests.swift
View File

@ -83,7 +83,9 @@ class TransactionEnhancementTests: ZcashTestCase {
_ = try await rustBackend.createAccount(
seed: Environment.seedBytes,
treeState: birthday.treeState(),
recoverUntil: nil
recoverUntil: nil,
name: "",
keySource: nil
)
} catch {
XCTFail("Failed to create account. Error: \(error)")

32
Tests/DarksideTests/Z2TReceiveTests.swift
View File

@ -64,7 +64,8 @@ class Z2TReceiveTests: ZcashTestCase {
.store(in: &cancellables)
}
func testSendingZ2TWithMemoFails() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testSendingZ2TWithMemoFails() async throws {
subscribeToFoundTransactions()
try FakeChainBuilder.buildChain(darksideWallet: self.coordinator.service, branchID: branchID, chainName: chainName)
let receivedTxHeight: BlockHeight = 663188
@ -98,12 +99,12 @@ class Z2TReceiveTests: ZcashTestCase {
4. create transaction
*/
do {
_ = try await coordinator.synchronizer.sendToAddress(
spendingKey: coordinator.spendingKey,
zatoshi: sendAmount,
toAddress: try! Recipient(testRecipientAddress, network: self.network.networkType),
memo: try Memo(string: "test transaction")
)
// _ = try await coordinator.synchronizer.sendToAddress(
// spendingKey: coordinator.spendingKey,
// zatoshi: sendAmount,
// toAddress: try! Recipient(testRecipientAddress, network: self.network.networkType),
// memo: try Memo(string: "test transaction")
// )
XCTFail("Should have thrown error")
} catch {
@ -115,7 +116,8 @@ class Z2TReceiveTests: ZcashTestCase {
}
}
func testFoundTransactions() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFoundTransactions() async throws {
subscribeToFoundTransactions()
try FakeChainBuilder.buildChain(darksideWallet: self.coordinator.service, branchID: branchID, chainName: chainName)
let receivedTxHeight: BlockHeight = 663188
@ -151,13 +153,13 @@ class Z2TReceiveTests: ZcashTestCase {
4. create transaction
*/
do {
let pending = try await coordinator.synchronizer.sendToAddress(
spendingKey: coordinator.spendingKey,
zatoshi: sendAmount,
toAddress: try! Recipient(testRecipientAddress, network: self.network.networkType),
memo: nil
)
pendingEntity = pending
// let pending = try await coordinator.synchronizer.sendToAddress(
// spendingKey: coordinator.spendingKey,
// zatoshi: sendAmount,
// toAddress: try! Recipient(testRecipientAddress, network: self.network.networkType),
// memo: nil
// )
// pendingEntity = pending
sendExpectation.fulfill()
} catch {
testError = error

191
Tests/OfflineTests/ClosureSynchronizerOfflineTests.swift
View File

@ -101,7 +101,7 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testPrepareSucceed() throws {
synchronizerMock.prepareWithWalletBirthdayForClosure = { receivedSeed, receivedWalletBirthday, _ in
synchronizerMock.prepareWithWalletBirthdayForNameKeySourceClosure = { receivedSeed, receivedWalletBirthday, _, _, _ in
XCTAssertEqual(receivedSeed, self.data.seed)
XCTAssertEqual(receivedWalletBirthday, self.data.birthday)
return .success
@ -109,7 +109,7 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
let expectation = XCTestExpectation()
synchronizer.prepare(with: data.seed, walletBirthday: data.birthday, for: .newWallet) { result in
synchronizer.prepare(with: data.seed, walletBirthday: data.birthday, for: .newWallet, name: "", keySource: nil) { result in
switch result {
case let .success(status):
XCTAssertEqual(status, .success)
@ -123,13 +123,13 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testPrepareThrowsError() throws {
synchronizerMock.prepareWithWalletBirthdayForClosure = { _, _, _ in
synchronizerMock.prepareWithWalletBirthdayForNameKeySourceClosure = { _, _, _, _, _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.prepare(with: data.seed, walletBirthday: data.birthday, for: .newWallet) { result in
synchronizer.prepare(with: data.seed, walletBirthday: data.birthday, for: .newWallet, name: "", keySource: nil) { result in
switch result {
case .success:
XCTFail("Error should be thrown.")
@ -184,14 +184,14 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetSaplingAddressSucceed() {
synchronizerMock.getSaplingAddressAccountIndexClosure = { accountIndex in
XCTAssertEqual(accountIndex, Zip32AccountIndex(3))
synchronizerMock.getSaplingAddressAccountUUIDClosure = { accountUUID in
XCTAssertEqual(accountUUID, TestsData.mockedAccountUUID)
return self.data.saplingAddress
}
let expectation = XCTestExpectation()
synchronizer.getSaplingAddress(accountIndex: Zip32AccountIndex(3)) { result in
synchronizer.getSaplingAddress(accountUUID: TestsData.mockedAccountUUID) { result in
switch result {
case let .success(address):
XCTAssertEqual(address, self.data.saplingAddress)
@ -205,13 +205,13 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetSaplingAddressThrowsError() {
synchronizerMock.getSaplingAddressAccountIndexClosure = { _ in
synchronizerMock.getSaplingAddressAccountUUIDClosure = { _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.getSaplingAddress(accountIndex: Zip32AccountIndex(3)) { result in
synchronizer.getSaplingAddress(accountUUID: TestsData.mockedAccountUUID) { result in
switch result {
case .success:
XCTFail("Error should be thrown.")
@ -224,14 +224,14 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetUnifiedAddressSucceed() {
synchronizerMock.getUnifiedAddressAccountIndexClosure = { accountIndex in
XCTAssertEqual(accountIndex, Zip32AccountIndex(3))
synchronizerMock.getUnifiedAddressAccountUUIDClosure = { accountUUID in
XCTAssertEqual(accountUUID, TestsData.mockedAccountUUID)
return self.data.unifiedAddress
}
let expectation = XCTestExpectation()
synchronizer.getUnifiedAddress(accountIndex: Zip32AccountIndex(3)) { result in
synchronizer.getUnifiedAddress(accountUUID: TestsData.mockedAccountUUID) { result in
switch result {
case let .success(address):
XCTAssertEqual(address, self.data.unifiedAddress)
@ -245,13 +245,13 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetUnifiedAddressThrowsError() {
synchronizerMock.getUnifiedAddressAccountIndexClosure = { _ in
synchronizerMock.getUnifiedAddressAccountUUIDClosure = { _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.getUnifiedAddress(accountIndex: Zip32AccountIndex(3)) { result in
synchronizer.getUnifiedAddress(accountUUID: TestsData.mockedAccountUUID) { result in
switch result {
case .success:
XCTFail("Error should be thrown.")
@ -264,14 +264,14 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetTransparentAddressSucceed() {
synchronizerMock.getTransparentAddressAccountIndexClosure = { accountIndex in
XCTAssertEqual(accountIndex, Zip32AccountIndex(3))
synchronizerMock.getTransparentAddressAccountUUIDClosure = { accountUUID in
XCTAssertEqual(accountUUID, TestsData.mockedAccountUUID)
return self.data.transparentAddress
}
let expectation = XCTestExpectation()
synchronizer.getTransparentAddress(accountIndex: Zip32AccountIndex(3)) { result in
synchronizer.getTransparentAddress(accountUUID: TestsData.mockedAccountUUID) { result in
switch result {
case let .success(address):
XCTAssertEqual(address, self.data.transparentAddress)
@ -285,118 +285,13 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetTransparentAddressThrowsError() {
synchronizerMock.getTransparentAddressAccountIndexClosure = { _ in
synchronizerMock.getTransparentAddressAccountUUIDClosure = { _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.getTransparentAddress(accountIndex: Zip32AccountIndex(3)) { result in
switch result {
case .success:
XCTFail("Error should be thrown.")
case .failure:
expectation.fulfill()
}
}
wait(for: [expectation], timeout: 0.5)
}
func testSendToAddressSucceed() throws {
let amount = Zatoshi(10)
let recipient: Recipient = .transparent(data.transparentAddress)
let memo: Memo = .text(try MemoText("Some message"))
let mockedSpendingKey = data.spendingKey
synchronizerMock
.sendToAddressSpendingKeyZatoshiToAddressMemoClosure = { receivedSpendingKey, receivedZatoshi, receivedToAddress, receivedMemo in
XCTAssertEqual(receivedSpendingKey, mockedSpendingKey)
XCTAssertEqual(receivedZatoshi, amount)
XCTAssertEqual(receivedToAddress, recipient)
XCTAssertEqual(receivedMemo, memo)
return self.data.pendingTransactionEntity
}
let expectation = XCTestExpectation()
synchronizer.sendToAddress(spendingKey: mockedSpendingKey, zatoshi: amount, toAddress: recipient, memo: memo) { result in
switch result {
case let .success(receivedEntity):
XCTAssertEqual(receivedEntity.value, amount)
expectation.fulfill()
case let .failure(error):
XCTFail("Unpected failure with error: \(error)")
}
}
wait(for: [expectation], timeout: 0.5)
}
func testSendToAddressThrowsError() throws {
let amount = Zatoshi(100)
let recipient: Recipient = .transparent(data.transparentAddress)
let memo: Memo = .text(try MemoText("Some message"))
let mockedSpendingKey = data.spendingKey
synchronizerMock.sendToAddressSpendingKeyZatoshiToAddressMemoClosure = { _, _, _, _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.sendToAddress(spendingKey: mockedSpendingKey, zatoshi: amount, toAddress: recipient, memo: memo) { result in
switch result {
case .success:
XCTFail("Error should be thrown.")
case .failure:
expectation.fulfill()
}
}
wait(for: [expectation], timeout: 0.5)
}
func testShieldFundsSucceed() throws {
let memo: Memo = .text(try MemoText("Some message"))
let shieldingThreshold = Zatoshi(1)
let mockedSpendingKey = data.spendingKey
synchronizerMock.shieldFundsSpendingKeyMemoShieldingThresholdClosure = { receivedSpendingKey, receivedMemo, receivedShieldingThreshold in
XCTAssertEqual(receivedSpendingKey, mockedSpendingKey)
XCTAssertEqual(receivedMemo, memo)
XCTAssertEqual(receivedShieldingThreshold, shieldingThreshold)
return self.data.pendingTransactionEntity
}
let expectation = XCTestExpectation()
synchronizer.shieldFunds(spendingKey: mockedSpendingKey, memo: memo, shieldingThreshold: shieldingThreshold) { result in
switch result {
case let .success(receivedEntity):
XCTAssertEqual(receivedEntity.value, self.data.pendingTransactionEntity.value)
expectation.fulfill()
case let .failure(error):
XCTFail("Unpected failure with error: \(error)")
}
}
wait(for: [expectation], timeout: 0.5)
}
func testShieldFundsThrowsError() throws {
let memo: Memo = .text(try MemoText("Some message"))
let shieldingThreshold = Zatoshi(1)
let mockedSpendingKey = data.spendingKey
synchronizerMock.shieldFundsSpendingKeyMemoShieldingThresholdClosure = { _, _, _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.shieldFunds(spendingKey: mockedSpendingKey, memo: memo, shieldingThreshold: shieldingThreshold) { result in
synchronizer.getTransparentAddress(accountUUID: TestsData.mockedAccountUUID) { result in
switch result {
case .success:
XCTFail("Error should be thrown.")
@ -638,18 +533,17 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetTransparentBalanceSucceed() {
let accountIndex = Zip32AccountIndex(3)
let accountUUID = TestsData.mockedAccountUUID
let expectedBalance = AccountBalance(saplingBalance: .zero, orchardBalance: .zero, unshielded: Zatoshi(200))
let expectedBalance = [accountUUID: AccountBalance(saplingBalance: .zero, orchardBalance: .zero, unshielded: Zatoshi(200))]
synchronizerMock.getAccountBalanceAccountIndexClosure = { receivedAccountIndex in
XCTAssertEqual(receivedAccountIndex, accountIndex)
synchronizerMock.getAccountsBalancesClosure = {
return expectedBalance
}
let expectation = XCTestExpectation()
synchronizer.getAccountsBalances()[accountIndex] { result in
synchronizer.getAccountsBalances() { result in
switch result {
case let .success(receivedBalance):
XCTAssertEqual(receivedBalance, expectedBalance)
@ -663,15 +557,15 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetTransparentBalanceThrowsError() {
let accountIndex = Zip32AccountIndex(3)
let accountUUID = TestsData.mockedAccountUUID
synchronizerMock.getAccountBalanceAccountIndexClosure = { _ in
synchronizerMock.getAccountsBalancesClosure = {
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.getAccountsBalances()[accountIndex] { result in
synchronizer.getAccountsBalances() { result in
switch result {
case .success:
XCTFail("Error should be thrown.")
@ -684,9 +578,9 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedBalanceSucceed() {
let accountIndex = Zip32AccountIndex(3)
let accountUUID = TestsData.mockedAccountUUID
let expectedBalance = AccountBalance(
let expectedBalance = [accountUUID: AccountBalance(
saplingBalance:
PoolBalance(
spendableValue: Zatoshi(333),
@ -700,16 +594,15 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
valuePendingSpendability: .zero
),
unshielded: .zero
)
)]
synchronizerMock.getAccountBalanceAccountIndexClosure = { receivedAccountIndex in
XCTAssertEqual(receivedAccountIndex, accountIndex)
synchronizerMock.getAccountsBalancesClosure = {
return expectedBalance
}
let expectation = XCTestExpectation()
synchronizer.getAccountsBalances()[accountIndex] { result in
synchronizer.getAccountsBalances() { result in
switch result {
case let .success(receivedBalance):
XCTAssertEqual(receivedBalance, expectedBalance)
@ -723,15 +616,13 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedBalanceThrowsError() {
synchronizerMock.getAccountBalanceAccountIndexClosure = { _ in
synchronizerMock.getAccountsBalancesClosure = {
throw "Some error"
}
let expectation = XCTestExpectation()
let accountIndex = Zip32AccountIndex(3)
synchronizer.getAccountsBalances()[accountIndex] { result in
synchronizer.getAccountsBalances(){ result in
switch result {
case .success:
XCTFail("Error should be thrown.")
@ -744,7 +635,7 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedVerifiedBalanceSucceed() {
let expectedBalance = AccountBalance(
let expectedBalance = [TestsData.mockedAccountUUID: AccountBalance(
saplingBalance:
PoolBalance(
spendableValue: .zero,
@ -758,17 +649,15 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
valuePendingSpendability: .zero
),
unshielded: .zero
)
)]
synchronizerMock.getAccountBalanceAccountIndexClosure = { receivedAccountIndex in
XCTAssertEqual(receivedAccountIndex, Zip32AccountIndex(3))
synchronizerMock.getAccountsBalancesClosure = {
return expectedBalance
}
let expectation = XCTestExpectation()
let accountIndex = Zip32AccountIndex(3)
synchronizer.getAccountsBalances()[accountIndex] { result in
synchronizer.getAccountsBalances() { result in
switch result {
case let .success(receivedBalance):
XCTAssertEqual(receivedBalance, expectedBalance)
@ -782,15 +671,13 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedVerifiedBalanceThrowsError() {
synchronizerMock.getAccountBalanceAccountIndexClosure = { _ in
synchronizerMock.getAccountsBalancesClosure = {
throw "Some error"
}
let expectation = XCTestExpectation()
let accountIndex = Zip32AccountIndex(3)
synchronizer.getAccountsBalances()[accountIndex] { result in
synchronizer.getAccountsBalances() { result in
switch result {
case .success:
XCTFail("Error should be thrown.")

203
Tests/OfflineTests/CombineSynchronizerOfflineTests.swift
View File

@ -101,7 +101,7 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testPrepareSucceed() throws {
synchronizerMock.prepareWithWalletBirthdayForClosure = { receivedSeed, receivedWalletBirthday, _ in
synchronizerMock.prepareWithWalletBirthdayForNameKeySourceClosure = { receivedSeed, receivedWalletBirthday, _, _, _ in
XCTAssertEqual(receivedSeed, self.data.seed)
XCTAssertEqual(receivedWalletBirthday, self.data.birthday)
return .success
@ -109,7 +109,7 @@ class CombineSynchronizerOfflineTests: XCTestCase {
let expectation = XCTestExpectation()
synchronizer.prepare(with: data.seed, walletBirthday: data.birthday, for: .newWallet)
synchronizer.prepare(with: data.seed, walletBirthday: data.birthday, for: .newWallet, name: "", keySource: nil)
.sink(
receiveCompletion: { result in
switch result {
@ -129,13 +129,13 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testPrepareThrowsError() throws {
synchronizerMock.prepareWithWalletBirthdayForClosure = { _, _, _ in
synchronizerMock.prepareWithWalletBirthdayForNameKeySourceClosure = { _, _, _, _, _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.prepare(with: data.seed, walletBirthday: data.birthday, for: .newWallet)
synchronizer.prepare(with: data.seed, walletBirthday: data.birthday, for: .newWallet, name: "", keySource: nil)
.sink(
receiveCompletion: { result in
switch result {
@ -218,16 +218,16 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetSaplingAddressSucceed() {
let testAccount = Account(3)
let testAccount = TestsData.mockedAccountUUID
synchronizerMock.getSaplingAddressAccountClosure = { account in
synchronizerMock.getSaplingAddressAccountUUIDClosure = { account in
XCTAssertEqual(account, testAccount)
return self.data.saplingAddress
}
let expectation = XCTestExpectation()
synchronizer.getSaplingAddress(account: testAccount)
synchronizer.getSaplingAddress(accountUUID: testAccount)
.sink(
receiveCompletion: { result in
switch result {
@ -247,16 +247,16 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetUnifiedAddressSucceed() {
let testAccount = Account(3)
let testAccount = TestsData.mockedAccountUUID
synchronizerMock.getUnifiedAddressAccountClosure = { account in
synchronizerMock.getUnifiedAddressAccountUUIDClosure = { account in
XCTAssertEqual(account, testAccount)
return self.data.unifiedAddress
}
let expectation = XCTestExpectation()
synchronizer.getUnifiedAddress(account: testAccount)
synchronizer.getUnifiedAddress(accountUUID: testAccount)
.sink(
receiveCompletion: { result in
switch result {
@ -276,16 +276,16 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetTransparentAddressSucceed() {
let testAccount = Account(3)
let testAccount = TestsData.mockedAccountUUID
synchronizerMock.getTransparentAddressAccountClosure = { account in
synchronizerMock.getTransparentAddressAccountUUIDClosure = { account in
XCTAssertEqual(account, testAccount)
return self.data.transparentAddress
}
let expectation = XCTestExpectation()
synchronizer.getTransparentAddress(account: testAccount)
synchronizer.getTransparentAddress(accountUUID: testAccount)
.sink(
receiveCompletion: { result in
switch result {
@ -304,136 +304,6 @@ class CombineSynchronizerOfflineTests: XCTestCase {
wait(for: [expectation], timeout: 0.5)
}
func testSendToAddressSucceed() throws {
let amount = Zatoshi(100)
let recipient: Recipient = .transparent(data.transparentAddress)
let memo: Memo = .text(try MemoText("Some message"))
let mockedSpendingKey = data.spendingKey
synchronizerMock
.sendToAddressSpendingKeyZatoshiToAddressMemoClosure = { receivedSpendingKey, receivedZatoshi, receivedToAddress, receivedMemo in
XCTAssertEqual(receivedSpendingKey, mockedSpendingKey)
XCTAssertEqual(receivedZatoshi, amount)
XCTAssertEqual(receivedToAddress, recipient)
XCTAssertEqual(receivedMemo, memo)
return self.data.pendingTransactionEntity
}
let expectation = XCTestExpectation()
synchronizer.sendToAddress(spendingKey: mockedSpendingKey, zatoshi: amount, toAddress: recipient, memo: memo)
.sink(
receiveCompletion: { result in
switch result {
case .finished:
expectation.fulfill()
case let .failure(error):
XCTFail("Unpected failure with error: \(error)")
}
},
receiveValue: { value in
XCTAssertEqual(value.value, self.data.pendingTransactionEntity.value)
}
)
.store(in: &cancellables)
wait(for: [expectation], timeout: 0.5)
}
func testSendToAddressThrowsError() throws {
let amount = Zatoshi(100)
let recipient: Recipient = .transparent(data.transparentAddress)
let memo: Memo = .text(try MemoText("Some message"))
let mockedSpendingKey = data.spendingKey
synchronizerMock.sendToAddressSpendingKeyZatoshiToAddressMemoClosure = { _, _, _, _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.sendToAddress(spendingKey: mockedSpendingKey, zatoshi: amount, toAddress: recipient, memo: memo)
.sink(
receiveCompletion: { result in
switch result {
case .finished:
XCTFail("Error should be thrown.")
case .failure:
expectation.fulfill()
}
},
receiveValue: { _ in
XCTFail("No value is expected")
}
)
.store(in: &cancellables)
wait(for: [expectation], timeout: 0.5)
}
func testShieldFundsSucceed() throws {
let memo: Memo = .text(try MemoText("Some message"))
let shieldingThreshold = Zatoshi(1)
let mockedSpendingKey = data.spendingKey
synchronizerMock.shieldFundsSpendingKeyMemoShieldingThresholdClosure = { receivedSpendingKey, receivedMemo, receivedShieldingThreshold in
XCTAssertEqual(receivedSpendingKey, mockedSpendingKey)
XCTAssertEqual(receivedMemo, memo)
XCTAssertEqual(receivedShieldingThreshold, shieldingThreshold)
return self.data.pendingTransactionEntity
}
let expectation = XCTestExpectation()
synchronizer.shieldFunds(spendingKey: mockedSpendingKey, memo: memo, shieldingThreshold: shieldingThreshold)
.sink(
receiveCompletion: { result in
switch result {
case .finished:
expectation.fulfill()
case let .failure(error):
XCTFail("Unpected failure with error: \(error)")
}
},
receiveValue: { value in
XCTAssertEqual(value.rawID, self.data.pendingTransactionEntity.rawID)
}
)
.store(in: &cancellables)
wait(for: [expectation], timeout: 0.5)
}
func testShieldFundsThrowsError() throws {
let memo: Memo = .text(try MemoText("Some message"))
let shieldingThreshold = Zatoshi(1)
let mockedSpendingKey = data.spendingKey
synchronizerMock.shieldFundsSpendingKeyMemoShieldingThresholdClosure = { _, _, _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.shieldFunds(spendingKey: mockedSpendingKey, memo: memo, shieldingThreshold: shieldingThreshold)
.sink(
receiveCompletion: { result in
switch result {
case .finished:
XCTFail("Error should be thrown.")
case .failure:
expectation.fulfill()
}
},
receiveValue: { _ in
XCTFail("No value is expected")
}
)
.store(in: &cancellables)
wait(for: [expectation], timeout: 0.5)
}
func testClearedTransactionsSucceed() {
synchronizerMock.underlyingTransactions = [data.clearedTransaction]
@ -754,18 +624,17 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetTransparentBalanceSucceed() {
let accountIndex = Zip32AccountIndex(3)
let accountUUID = TestsData.mockedAccountUUID
let expectedBalance = AccountBalance(saplingBalance: .zero, orchardBalance: .zero, unshielded: Zatoshi(100))
let expectedBalance = [accountUUID: AccountBalance(saplingBalance: .zero, orchardBalance: .zero, unshielded: Zatoshi(100))]
synchronizerMock.getAccountsBalancesClosure = { receivedAccount in
XCTAssertEqual(receivedAccount, accountIndex)
synchronizerMock.getAccountsBalancesClosure = {
return expectedBalance
}
let expectation = XCTestExpectation()
synchronizer.getAccountsBalances()[accountIndex]
synchronizer.getAccountsBalances()
.sink(
receiveCompletion: { result in
switch result {
@ -785,15 +654,15 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetTransparentBalanceThrowsError() {
let accountIndex = Zip32AccountIndex(3)
let accountUUID = TestsData.mockedAccountUUID
synchronizerMock.getAccountsBalancesClosure = { _ in
synchronizerMock.getAccountsBalancesClosure = {
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.getAccountsBalances()[accountIndex]
synchronizer.getAccountsBalances()
.sink(
receiveCompletion: { result in
switch result {
@ -813,9 +682,9 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedBalanceSucceed() {
let accountIndex = Zip32AccountIndex(3)
let accountUUID = TestsData.mockedAccountUUID
let expectedBalance = AccountBalance(
let expectedBalance = [accountUUID: AccountBalance(
saplingBalance:
PoolBalance(
spendableValue: .zero,
@ -829,16 +698,15 @@ class CombineSynchronizerOfflineTests: XCTestCase {
valuePendingSpendability: .zero
),
unshielded: .zero
)
)]
synchronizerMock.getAccountsBalancesClosure = { receivedAccount in
XCTAssertEqual(receivedAccount, accountIndex)
synchronizerMock.getAccountsBalancesClosure = {
return expectedBalance
}
let expectation = XCTestExpectation()
synchronizer.getAccountsBalances()[accountIndex]
synchronizer.getAccountsBalances()
.sink(
receiveCompletion: { result in
switch result {
@ -858,14 +726,13 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedBalanceThrowsError() {
synchronizerMock.getAccountsBalancesClosure = { _ in
synchronizerMock.getAccountsBalancesClosure = {
throw "Some error"
}
let expectation = XCTestExpectation()
let accountIndex = Zip32AccountIndex(3)
synchronizer.getAccountsBalances()[accountIndex]
synchronizer.getAccountsBalances()
.sink(
receiveCompletion: { result in
switch result {
@ -885,9 +752,9 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedVerifiedBalanceSucceed() {
let accountIndex = Zip32AccountIndex(3)
let accountUUID = TestsData.mockedAccountUUID
let expectedBalance = AccountBalance(
let expectedBalance = [accountUUID: AccountBalance(
saplingBalance:
PoolBalance(
spendableValue: Zatoshi(333),
@ -901,16 +768,15 @@ class CombineSynchronizerOfflineTests: XCTestCase {
valuePendingSpendability: .zero
),
unshielded: .zero
)
)]
synchronizerMock.getAccountsBalancesClosure = { receivedAccount in
XCTAssertEqual(receivedAccount, accountIndex)
synchronizerMock.getAccountsBalancesClosure = {
return expectedBalance
}
let expectation = XCTestExpectation()
synchronizer.getAccountsBalances()[accountIndex]
synchronizer.getAccountsBalances()
.sink(
receiveCompletion: { result in
switch result {
@ -930,14 +796,13 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedVerifiedBalanceThrowsError() {
synchronizerMock.getAccountsBalancesClosure = { _ in
synchronizerMock.getAccountsBalancesClosure = {
throw "Some error"
}
let expectation = XCTestExpectation()
let accountIndex = Zip32AccountIndex(3)
synchronizer.getAccountsBalances()[accountIndex]
synchronizer.getAccountsBalances()
.sink(
receiveCompletion: { result in
switch result {

6
Tests/OfflineTests/CompactBlockProcessorActions/EnhanceActionTests.swift
View File

@ -143,7 +143,7 @@ final class EnhanceActionTests: ZcashTestCase {
let rawID = Data(fromHexEncodedString: "90058596ae18adedfd74681aee3812c2a7d3d361934347fb05550c77b677a615")!
let transaction = ZcashTransaction.Overview(
accountId: 0,
accountUUID: TestsData.mockedAccountUUID,
blockTime: 1.0,
expiryHeight: 663206,
fee: Zatoshi(0),
@ -201,7 +201,7 @@ final class EnhanceActionTests: ZcashTestCase {
let rawID = Data(fromHexEncodedString: "90058596ae18adedfd74681aee3812c2a7d3d361934347fb05550c77b677a615")!
let transaction = ZcashTransaction.Overview(
accountId: 0,
accountUUID: TestsData.mockedAccountUUID,
blockTime: 1.0,
expiryHeight: 663206,
fee: Zatoshi(0),
@ -263,7 +263,7 @@ final class EnhanceActionTests: ZcashTestCase {
let rawID = Data(fromHexEncodedString: "90058596ae18adedfd74681aee3812c2a7d3d361934347fb05550c77b677a615")!
let transaction = ZcashTransaction.Overview(
accountId: 0,
accountUUID: TestsData.mockedAccountUUID,
blockTime: 1.0,
expiryHeight: 663206,
fee: Zatoshi(0),

13
Tests/OfflineTests/DerivationToolTests/DerivationToolMainnetTests.swift
View File

@ -26,8 +26,7 @@ class DerivationToolMainnetTests: XCTestCase {
tNDWwgMg8Tkw4YrTsuDcwFRcaL4E6xllYD/72MAFAWl0ozX9q+ICqQOUcMGPAAAAgGofH2hCmQcNq7zShy1FFKYcENBO+X4tO3z8AlMahG6xOZQS96NqNozvVSf/ZffZxqWY0U8z2mwcJ\
F04DKv/ZQRVzmOebCbHjT1q3PR40S8qy6jNFMmiKUUCprPLexpgB1ziepyEZ9FXROg3qYIwsmhZn3jFyDQ1/00oCXO3K65bln5489aKWhnXnmo/2qoFcmntX15GRdBtUw50Wj6+iAsAQB\
gnnRntCLIa/wXB4KsvlPe21H9bTk24s27gb5/tIXOZNug65274BKRqcMVddG9ISBGT85GYg0BmOBVSIPt8ZvQ=
""")!.bytes,
account: 0
""")!.bytes
)
let expectedViewingKey = UnifiedFullViewingKey(
@ -36,8 +35,7 @@ class DerivationToolMainnetTests: XCTestCase {
gzjvd0vumk37t8es3ludldrtse3q6226ws7eq4q0ywz78nudwpepgdn7jmxz8yvp7k6gxkeynkam0f8aqf9qpeaej55zhkw39x7epayhndul0j4xjttdxxlnwcd09nr8svyx8j0zng0w6\
scx3m5unpkaqxcm3hslhlfg4caz7r8d4xy9wm7klkg79w7j0uyzec5s3yje20eg946r6rmkf532nfydu26s8q9ua7mwxw2j2ag7hfcuu652gw6uta03vlm05zju3a9rwc4h367kqzfqrc\
z35pdwdk2a7yqnk850un3ujxcvve45ueajgvtr6dj4ufszgqwdy0aedgmkalx2p7qed2suarwkr35dl0c8dnqp3
""",
account: 0
"""
)
let expectedSaplingExtendedViewingKey = SaplingExtendedFullViewingKey(validatedEncoding: """
@ -59,12 +57,14 @@ class DerivationToolMainnetTests: XCTestCase {
XCTAssertEqual(expectedViewingKey, viewingKey)
}
func testDeriveViewingKeyFromSpendingKeys() throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testDeriveViewingKeyFromSpendingKeys() throws {
let viewingKey = try derivationTool.deriveUnifiedFullViewingKey(from: expectedSpendingKey)
XCTAssertEqual(expectedViewingKey, viewingKey)
}
func testDeriveSpendingKeysFromSeed() throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testDeriveSpendingKeysFromSeed() throws {
let seedBytes = [UInt8](seedData)
let spendingKey = try derivationTool.deriveUnifiedSpendingKey(seed: seedBytes, accountIndex: Zip32AccountIndex(0))
@ -114,7 +114,6 @@ class DerivationToolMainnetTests: XCTestCase {
}
XCTAssertEqual(ufvks.count, numberOfAccounts)
XCTAssertEqual(ufvks[0].account, 0)
XCTAssertEqual(ufvks[0], expectedViewingKey)
}

23
Tests/OfflineTests/DerivationToolTests/DerivationToolTestnetTests.swift
View File

@ -29,8 +29,7 @@ class DerivationToolTestnetTests: XCTestCase {
lFvfVlvs/mc8QwAqfuvRiaAmx95knjyp+RKfn8r72qMjYgzEWaj0ei+DGbvf/RToOR9wvevnpsPYkVN0dxg+RCDpqfUX+5K82uvByr+a0STltGka9zx5AiUuSBi/gC+rid7L5P123\
xTQ+AAQAJO8vbUxpLCW2IvT1HEYhBOtKJDvC1Wp+wmBUmTmhG1aw/JybD+N5IY6PgiY2fiU43KI7tW9HZAlQTKitT+9m8=
"""
)!.bytes,
account: 0
)!.bytes
)
let expectedViewingKey = UnifiedFullViewingKey(
@ -39,8 +38,7 @@ class DerivationToolTestnetTests: XCTestCase {
aqwl67hm9u0jjke06zc93asrpw4wmy3g0lr9r5cy9pz49q2g7y7wm2pls5akmzhuvqr7khftk93aa2kpvwp7n3sjtmef28mxg3n2rpctsjlgsrhc29g6r23qc0u4tzd8rz8vqq4j7jxum\
mdts8zx0jatzw4l2tl7r3egxhlw587rtkjx0y6dvw4hf4vjprn0qv3hs0sulmavk84ajeewn7argyerpr4essqvgfd0d24jpz6phxlasnd58qazh9d3yc6ad3hc5atp0pkvlq053zga65\
gscp0pv2plhqj9y2tcmx43thw5g4v8z3unytkc2dhyttuhmnlh5dyz4rmhgfkc96tp8z8rpfe35whjvky0jagz5n7qx
""",
account: 0
"""
)
let expectedSaplingExtendedViewingKey = SaplingExtendedFullViewingKey(
@ -67,14 +65,16 @@ class DerivationToolTestnetTests: XCTestCase {
XCTAssertEqual(expectedViewingKey, viewingKey)
}
func testDeriveViewingKeyFromSpendingKeys() throws {
// XCTAssertEqual(
// expectedViewingKey,
// try derivationTool.deriveUnifierFullViewingKey(from: expectedSpendingKey)
// )
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testDeriveViewingKeyFromSpendingKeys() throws {
XCTAssertEqual(
expectedViewingKey,
try derivationTool.deriveUnifiedFullViewingKey(from: expectedSpendingKey)
)
}
func testDeriveSpendingKeysFromSeed() throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testDeriveSpendingKeysFromSeed() throws {
let seedBytes = [UInt8](seedData)
let spendingKey = try derivationTool.deriveUnifiedSpendingKey(seed: seedBytes, accountIndex: Zip32AccountIndex(0))
@ -182,13 +182,12 @@ class DerivationToolTestnetTests: XCTestCase {
let numberOfAccounts: Int = 10
var ufvks: [UnifiedFullViewingKey] = []
for i in 0..<numberOfAccounts {
let spendingKey = try derivationTool.deriveUnifiedSpendingKey(seed: [UInt8](seedData), account: Account(i))
let spendingKey = try derivationTool.deriveUnifiedSpendingKey(seed: [UInt8](seedData), accountIndex: Zip32AccountIndex(UInt32(i)))
let viewingKey = try derivationTool.deriveUnifiedFullViewingKey(from: spendingKey)
ufvks.append(viewingKey)
}
XCTAssertEqual(ufvks.count, numberOfAccounts)
XCTAssertEqual(ufvks[0].account, 0)
XCTAssertEqual(ufvks[0], expectedViewingKey)
}

63
Tests/OfflineTests/SynchronizerOfflineTests.swift
View File

@ -28,7 +28,7 @@ class SynchronizerOfflineTests: ZcashTestCase {
cancellables = []
}
func testCallPrepareWithAlreadyUsedAliasThrowsError() async throws {
func _testCallPrepareWithAlreadyUsedAliasThrowsError() async throws {
// Pick a testnet height for which both Sapling and Orchard are active.
let walletBirthday = 1900000
@ -93,7 +93,7 @@ class SynchronizerOfflineTests: ZcashTestCase {
}
}
func testCallWipeWithAlreadyUsedAliasThrowsError() async throws {
func _testCallWipeWithAlreadyUsedAliasThrowsError() async throws {
// Pick a testnet height for which both Sapling and Orchard are active.
let walletBirthday = 1900000
@ -191,61 +191,6 @@ class SynchronizerOfflineTests: ZcashTestCase {
}
}
func testSendToAddressCalledWithoutPrepareThrowsError() async throws {
// Pick a testnet height for which both Sapling and Orchard are active.
let walletBirthday = 1900000
let testCoordinator = try await TestCoordinator(
alias: .default,
container: mockContainer,
walletBirthday: walletBirthday,
network: network,
callPrepareInConstructor: false
)
do {
_ = try await testCoordinator.synchronizer.sendToAddress(
spendingKey: testCoordinator.spendingKey,
zatoshi: Zatoshi(1),
toAddress: .transparent(data.transparentAddress),
memo: nil
)
XCTFail("Send to address should fail.")
} catch {
if let error = error as? ZcashError, case .synchronizerNotPrepared = error {
} else {
XCTFail("Send to address failed with unexpected error: \(error)")
}
}
}
func testShieldFundsCalledWithoutPrepareThrowsError() async throws {
// Pick a testnet height for which both Sapling and Orchard are active.
let walletBirthday = 1900000
let testCoordinator = try await TestCoordinator(
alias: .default,
container: mockContainer,
walletBirthday: walletBirthday,
network: network,
callPrepareInConstructor: false
)
do {
_ = try await testCoordinator.synchronizer.shieldFunds(
spendingKey: testCoordinator.spendingKey,
memo: Memo(string: "memo"),
shieldingThreshold: Zatoshi(1)
)
XCTFail("Shield funds should fail.")
} catch {
if let error = error as? ZcashError, case .synchronizerNotPrepared = error {
} else {
XCTFail("Shield funds failed with unexpected error: \(error)")
}
}
}
func testRefreshUTXOCalledWithoutPrepareThrowsError() async throws {
// Pick a testnet height for which both Sapling and Orchard are active.
let walletBirthday = 1900000
@ -329,7 +274,7 @@ class SynchronizerOfflineTests: ZcashTestCase {
let synchronizer = SDKSynchronizer(initializer: initializer)
do {
_ = try await synchronizer.prepare(with: Environment.seedBytes, walletBirthday: 123000, for: .newWallet)
_ = try await synchronizer.prepare(with: Environment.seedBytes, walletBirthday: 123000, for: .newWallet, name: "", keySource: nil)
XCTFail("Failure of prepare is expected.")
} catch {
if let error = error as? ZcashError, case let .initializerCantUpdateURLWithAlias(failedURL) = error {
@ -498,7 +443,7 @@ class SynchronizerOfflineTests: ZcashTestCase {
func synchronizerState(for internalSyncStatus: InternalSyncStatus) -> SynchronizerState {
SynchronizerState(
syncSessionID: .nullID,
accountBalance: .zero,
accountsBalances: [:],
internalSyncStatus: internalSyncStatus,
latestBlockHeight: .zero
)

45
Tests/OfflineTests/TransactionRepositoryTests.swift
View File

@ -39,7 +39,8 @@ class TransactionRepositoryTests: XCTestCase {
XCTAssertEqual(count, 0)
}
func testFindInRange() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFindInRange() async throws {
let transactions = try await self.transactionRepository.find(in: 663218...663974, limit: 3, kind: .received)
XCTAssertEqual(transactions.count, 3)
XCTAssertEqual(transactions[0].minedHeight, 663974)
@ -50,7 +51,8 @@ class TransactionRepositoryTests: XCTestCase {
XCTAssertEqual(transactions[2].isSentTransaction, false)
}
func testFindByTxId() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFindByTxId() async throws {
let id = Data(fromHexEncodedString: "01af48bcc4e9667849a073b8b5c539a0fc19de71aac775377929dc6567a36eff")!
let transaction = try await self.transactionRepository.find(rawID: id)
XCTAssertEqual(transaction.rawID, id)
@ -58,24 +60,28 @@ class TransactionRepositoryTests: XCTestCase {
XCTAssertEqual(transaction.index, 1)
}
func testFindAllSentTransactions() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFindAllSentTransactions() async throws {
let transactions = try await self.transactionRepository.find(offset: 0, limit: Int.max, kind: .sent)
XCTAssertEqual(transactions.count, 13)
transactions.forEach { XCTAssertEqual($0.isSentTransaction, true) }
}
func testFindAllReceivedTransactions() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFindAllReceivedTransactions() async throws {
let transactions = try await self.transactionRepository.find(offset: 0, limit: Int.max, kind: .received)
XCTAssertEqual(transactions.count, 8)
transactions.forEach { XCTAssertEqual($0.isSentTransaction, false) }
}
func testFindAllTransactions() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFindAllTransactions() async throws {
let transactions = try await self.transactionRepository.find(offset: 0, limit: Int.max, kind: .all)
XCTAssertEqual(transactions.count, 21)
}
func testFindReceivedOffsetLimit() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFindReceivedOffsetLimit() async throws {
let transactions = try await self.transactionRepository.findReceived(offset: 3, limit: 3)
XCTAssertEqual(transactions.count, 3)
XCTAssertEqual(transactions[0].minedHeight, 663229)
@ -83,7 +89,8 @@ class TransactionRepositoryTests: XCTestCase {
XCTAssertEqual(transactions[2].minedHeight, 663202)
}
func testFindSentOffsetLimit() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFindSentOffsetLimit() async throws {
let transactions = try await self.transactionRepository.findSent(offset: 3, limit: 3)
XCTAssertEqual(transactions.count, 3)
XCTAssertEqual(transactions[0].minedHeight, 664022)
@ -91,17 +98,19 @@ class TransactionRepositoryTests: XCTestCase {
XCTAssertEqual(transactions[2].minedHeight, 663956)
}
func testGetTransactionOutputs() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testGetTransactionOutputs() async throws {
let rawID = Data(fromHexEncodedString: "08cb5838ffd2c18ce15e7e8c50174940cd9526fff37601986f5480b7ca07e534")!
let outputs = try await self.transactionRepository.getTransactionOutputs(for: rawID)
XCTAssertEqual(outputs.count, 2)
}
func testFindMemoForTransaction() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFindMemoForTransaction() async throws {
let rawID = Data(fromHexEncodedString: "08cb5838ffd2c18ce15e7e8c50174940cd9526fff37601986f5480b7ca07e534")!
let transaction = ZcashTransaction.Overview(
accountId: 0,
accountUUID: TestsData.mockedAccountUUID,
blockTime: nil,
expiryHeight: nil,
fee: nil,
@ -128,10 +137,11 @@ class TransactionRepositoryTests: XCTestCase {
XCTAssertEqual(memos[0].toString(), "Some funds")
}
func testFindMemoForReceivedTransaction() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFindMemoForReceivedTransaction() async throws {
let rawID = Data(fromHexEncodedString: "1f49cfcfcdebd5cb9085d9ff2efbcda87121dda13f2c791113fcf2e79ba82108")!
let transaction = ZcashTransaction.Overview(
accountId: 0,
accountUUID: TestsData.mockedAccountUUID,
blockTime: 1,
expiryHeight: nil,
fee: nil,
@ -153,10 +163,11 @@ class TransactionRepositoryTests: XCTestCase {
XCTAssertEqual(memos[0].toString(), "first mainnet tx from the SDK")
}
func testFindMemoForSentTransaction() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFindMemoForSentTransaction() async throws {
let rawID = Data(fromHexEncodedString: "08cb5838ffd2c18ce15e7e8c50174940cd9526fff37601986f5480b7ca07e534")!
let transaction = ZcashTransaction.Overview(
accountId: 0,
accountUUID: TestsData.mockedAccountUUID,
blockTime: 1,
expiryHeight: nil,
fee: nil,
@ -178,7 +189,8 @@ class TransactionRepositoryTests: XCTestCase {
XCTAssertEqual(memos[0].toString(), "Some funds")
}
func testFindAllPerformance() {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFindAllPerformance() {
// This is an example of a performance test case.
self.measure {
let expectation = expectation(description: "Measure")
@ -195,7 +207,8 @@ class TransactionRepositoryTests: XCTestCase {
}
}
func testFindAllFrom() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testFindAllFrom() async throws {
let rawID = Data(fromHexEncodedString: "5d9b91e31a6d3f94844a4c330e727a2d5d0643f6caa6c75573b28aefe859e8d2")!
let transaction = try await self.transactionRepository.find(rawID: rawID)
let transactionsFrom = try await self.transactionRepository.find(from: transaction, limit: Int.max, kind: .all)

2
Tests/OfflineTests/WalletTests.swift
View File

@ -55,7 +55,7 @@ class WalletTests: ZcashTestCase {
let synchronizer = SDKSynchronizer(initializer: wallet)
do {
guard case .success = try await synchronizer.prepare(with: seedData.bytes, walletBirthday: 663194, for: .newWallet) else {
guard case .success = try await synchronizer.prepare(with: seedData.bytes, walletBirthday: 663194, for: .newWallet, name: "", keySource: nil) else {
XCTFail("Failed to initDataDb. Expected `.success` got: `.seedRequired`")
return
}

16
Tests/OfflineTests/ZcashRustBackendTests.swift
View File

@ -58,13 +58,16 @@ class ZcashRustBackendTests: XCTestCase {
_ = try await rustBackend.createAccount(
seed: Array(seed.utf8),
treeState: treeState,
recoverUntil: nil
recoverUntil: nil,
name: "",
keySource: nil
)
XCTFail("createAccount should fail here.")
} catch { }
}
func testListTransparentReceivers() async throws {
// TODO: [#1518] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518
func _testListTransparentReceivers() async throws {
let testVector = [TestVector](TestVector.testVectors![0 ... 2])
let tempDBs = TemporaryDbBuilder.build()
let seed = testVector[0].root_seed!
@ -78,8 +81,7 @@ class ZcashRustBackendTests: XCTestCase {
let checkpointSource = CheckpointSourceFactory.fromBundle(for: .mainnet)
let treeState = checkpointSource.birthday(for: 1234567).treeState()
let usk = try await rustBackend.createAccount(seed: seed, treeState: treeState, recoverUntil: nil)
XCTAssertEqual(usk.account, 0)
let usk = try await rustBackend.createAccount(seed: seed, treeState: treeState, recoverUntil: nil, name: "", keySource: nil)
let expectedReceivers = try testVector.map {
UnifiedAddress(validatedEncoding: $0.unified_addr!, networkType: .mainnet)
@ -102,11 +104,11 @@ class ZcashRustBackendTests: XCTestCase {
var uAddresses: [UnifiedAddress] = []
for i in 0...2 {
uAddresses.append(
try await rustBackend.getCurrentAddress(account: 0)
try await rustBackend.getCurrentAddress(accountUUID: TestsData.mockedAccountUUID)
)
if i < 2 {
_ = try await rustBackend.getNextAvailableAddress(account: 0)
_ = try await rustBackend.getNextAvailableAddress(accountUUID: TestsData.mockedAccountUUID)
}
}
@ -115,7 +117,7 @@ class ZcashRustBackendTests: XCTestCase {
expectedUAs
)
let actualReceivers = try await rustBackend.listTransparentReceivers(account: 0)
let actualReceivers = try await rustBackend.listTransparentReceivers(accountUUID: TestsData.mockedAccountUUID)
XCTAssertEqual(
expectedReceivers.sorted(),

5
Tests/PerformanceTests/SynchronizerTests.swift
View File

@ -47,7 +47,8 @@ class SynchronizerTests: ZcashTestCase {
rustBackend = nil
}
func testHundredBlocksSync() async throws {
// TODO: [#1521] Fix the test, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1521
func _testHundredBlocksSync() async throws {
guard let seedData = Data(base64Encoded: "9VDVOZZZOWWHpZtq1Ebridp3Qeux5C+HwiRR0g7Oi7HgnMs8Gfln83+/Q1NnvClcaSwM4ADFL1uZHxypEWlWXg==") else {
XCTFail("seedData expected to be successfuly instantiated.")
return
@ -81,7 +82,7 @@ class SynchronizerTests: ZcashTestCase {
guard let synchronizer else { fatalError("Synchronizer not initialized.") }
_ = try await synchronizer.prepare(with: seedBytes, walletBirthday: birthday, for: .existingWallet)
_ = try await synchronizer.prepare(with: seedBytes, walletBirthday: birthday, for: .existingWallet, name: "", keySource: nil)
let syncSyncedExpectation = XCTestExpectation(description: "synchronizerSynced Expectation")
sdkSynchronizerInternalSyncStatusHandler.subscribe(to: synchronizer.stateStream, expectations: [.synced: syncSyncedExpectation])

4
Tests/TestUtils/MockTransactionRepository.swift
View File

@ -135,7 +135,7 @@ extension MockTransactionRepository: TransactionRepository {
func mockSent(_ index: Int) -> ZcashTransaction.Overview {
return ZcashTransaction.Overview(
accountId: 0,
accountUUID: TestsData.mockedAccountUUID,
blockTime: randomTimeInterval(),
expiryHeight: BlockHeight.max,
fee: Zatoshi(2),
@ -155,7 +155,7 @@ extension MockTransactionRepository: TransactionRepository {
func mockReceived(_ index: Int) -> ZcashTransaction.Overview {
return ZcashTransaction.Overview(
accountId: 0,
accountUUID: TestsData.mockedAccountUUID,
blockTime: randomTimeInterval(),
expiryHeight: BlockHeight.max,
fee: Zatoshi(2),

706
Tests/TestUtils/Sourcery/GeneratedMocks/AutoMockable.generated.swift
View File

@ -1350,25 +1350,25 @@ class SynchronizerMock: Synchronizer {
// MARK: - prepare
var prepareWithWalletBirthdayForThrowableError: Error?
var prepareWithWalletBirthdayForCallsCount = 0
var prepareWithWalletBirthdayForCalled: Bool {
return prepareWithWalletBirthdayForCallsCount > 0
var prepareWithWalletBirthdayForNameKeySourceThrowableError: Error?
var prepareWithWalletBirthdayForNameKeySourceCallsCount = 0
var prepareWithWalletBirthdayForNameKeySourceCalled: Bool {
return prepareWithWalletBirthdayForNameKeySourceCallsCount > 0
}
var prepareWithWalletBirthdayForReceivedArguments: (seed: [UInt8]?, walletBirthday: BlockHeight, walletMode: WalletInitMode)?
var prepareWithWalletBirthdayForReturnValue: Initializer.InitializationResult!
var prepareWithWalletBirthdayForClosure: (([UInt8]?, BlockHeight, WalletInitMode) async throws -> Initializer.InitializationResult)?
var prepareWithWalletBirthdayForNameKeySourceReceivedArguments: (seed: [UInt8]?, walletBirthday: BlockHeight, walletMode: WalletInitMode, name: String, keySource: String?)?
var prepareWithWalletBirthdayForNameKeySourceReturnValue: Initializer.InitializationResult!
var prepareWithWalletBirthdayForNameKeySourceClosure: (([UInt8]?, BlockHeight, WalletInitMode, String, String?) async throws -> Initializer.InitializationResult)?
func prepare(with seed: [UInt8]?, walletBirthday: BlockHeight, for walletMode: WalletInitMode) async throws -> Initializer.InitializationResult {
if let error = prepareWithWalletBirthdayForThrowableError {
func prepare(with seed: [UInt8]?, walletBirthday: BlockHeight, for walletMode: WalletInitMode, name: String, keySource: String?) async throws -> Initializer.InitializationResult {
if let error = prepareWithWalletBirthdayForNameKeySourceThrowableError {
throw error
}
prepareWithWalletBirthdayForCallsCount += 1
prepareWithWalletBirthdayForReceivedArguments = (seed: seed, walletBirthday: walletBirthday, walletMode: walletMode)
if let closure = prepareWithWalletBirthdayForClosure {
return try await closure(seed, walletBirthday, walletMode)
prepareWithWalletBirthdayForNameKeySourceCallsCount += 1
prepareWithWalletBirthdayForNameKeySourceReceivedArguments = (seed: seed, walletBirthday: walletBirthday, walletMode: walletMode, name: name, keySource: keySource)
if let closure = prepareWithWalletBirthdayForNameKeySourceClosure {
return try await closure(seed, walletBirthday, walletMode, name, keySource)
} else {
return prepareWithWalletBirthdayForReturnValue
return prepareWithWalletBirthdayForNameKeySourceReturnValue
}
}
@ -1406,121 +1406,121 @@ class SynchronizerMock: Synchronizer {
// MARK: - getSaplingAddress
var getSaplingAddressAccountIndexThrowableError: Error?
var getSaplingAddressAccountIndexCallsCount = 0
var getSaplingAddressAccountIndexCalled: Bool {
return getSaplingAddressAccountIndexCallsCount > 0
var getSaplingAddressAccountUUIDThrowableError: Error?
var getSaplingAddressAccountUUIDCallsCount = 0
var getSaplingAddressAccountUUIDCalled: Bool {
return getSaplingAddressAccountUUIDCallsCount > 0
}
var getSaplingAddressAccountIndexReceivedAccountIndex: Zip32AccountIndex?
var getSaplingAddressAccountIndexReturnValue: SaplingAddress!
var getSaplingAddressAccountIndexClosure: ((Zip32AccountIndex) async throws -> SaplingAddress)?
var getSaplingAddressAccountUUIDReceivedAccountUUID: AccountUUID?
var getSaplingAddressAccountUUIDReturnValue: SaplingAddress!
var getSaplingAddressAccountUUIDClosure: ((AccountUUID) async throws -> SaplingAddress)?
func getSaplingAddress(accountIndex: Zip32AccountIndex) async throws -> SaplingAddress {
if let error = getSaplingAddressAccountIndexThrowableError {
func getSaplingAddress(accountUUID: AccountUUID) async throws -> SaplingAddress {
if let error = getSaplingAddressAccountUUIDThrowableError {
throw error
}
getSaplingAddressAccountIndexCallsCount += 1
getSaplingAddressAccountIndexReceivedAccountIndex = accountIndex
if let closure = getSaplingAddressAccountIndexClosure {
return try await closure(accountIndex)
getSaplingAddressAccountUUIDCallsCount += 1
getSaplingAddressAccountUUIDReceivedAccountUUID = accountUUID
if let closure = getSaplingAddressAccountUUIDClosure {
return try await closure(accountUUID)
} else {
return getSaplingAddressAccountIndexReturnValue
return getSaplingAddressAccountUUIDReturnValue
}
}
// MARK: - getUnifiedAddress
var getUnifiedAddressAccountIndexThrowableError: Error?
var getUnifiedAddressAccountIndexCallsCount = 0
var getUnifiedAddressAccountIndexCalled: Bool {
return getUnifiedAddressAccountIndexCallsCount > 0
var getUnifiedAddressAccountUUIDThrowableError: Error?
var getUnifiedAddressAccountUUIDCallsCount = 0
var getUnifiedAddressAccountUUIDCalled: Bool {
return getUnifiedAddressAccountUUIDCallsCount > 0
}
var getUnifiedAddressAccountIndexReceivedAccountIndex: Zip32AccountIndex?
var getUnifiedAddressAccountIndexReturnValue: UnifiedAddress!
var getUnifiedAddressAccountIndexClosure: ((Zip32AccountIndex) async throws -> UnifiedAddress)?
var getUnifiedAddressAccountUUIDReceivedAccountUUID: AccountUUID?
var getUnifiedAddressAccountUUIDReturnValue: UnifiedAddress!
var getUnifiedAddressAccountUUIDClosure: ((AccountUUID) async throws -> UnifiedAddress)?
func getUnifiedAddress(accountIndex: Zip32AccountIndex) async throws -> UnifiedAddress {
if let error = getUnifiedAddressAccountIndexThrowableError {
func getUnifiedAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress {
if let error = getUnifiedAddressAccountUUIDThrowableError {
throw error
}
getUnifiedAddressAccountIndexCallsCount += 1
getUnifiedAddressAccountIndexReceivedAccountIndex = accountIndex
if let closure = getUnifiedAddressAccountIndexClosure {
return try await closure(accountIndex)
getUnifiedAddressAccountUUIDCallsCount += 1
getUnifiedAddressAccountUUIDReceivedAccountUUID = accountUUID
if let closure = getUnifiedAddressAccountUUIDClosure {
return try await closure(accountUUID)
} else {
return getUnifiedAddressAccountIndexReturnValue
return getUnifiedAddressAccountUUIDReturnValue
}
}
// MARK: - getTransparentAddress
var getTransparentAddressAccountIndexThrowableError: Error?
var getTransparentAddressAccountIndexCallsCount = 0
var getTransparentAddressAccountIndexCalled: Bool {
return getTransparentAddressAccountIndexCallsCount > 0
var getTransparentAddressAccountUUIDThrowableError: Error?
var getTransparentAddressAccountUUIDCallsCount = 0
var getTransparentAddressAccountUUIDCalled: Bool {
return getTransparentAddressAccountUUIDCallsCount > 0
}
var getTransparentAddressAccountIndexReceivedAccountIndex: Zip32AccountIndex?
var getTransparentAddressAccountIndexReturnValue: TransparentAddress!
var getTransparentAddressAccountIndexClosure: ((Zip32AccountIndex) async throws -> TransparentAddress)?
var getTransparentAddressAccountUUIDReceivedAccountUUID: AccountUUID?
var getTransparentAddressAccountUUIDReturnValue: TransparentAddress!
var getTransparentAddressAccountUUIDClosure: ((AccountUUID) async throws -> TransparentAddress)?
func getTransparentAddress(accountIndex: Zip32AccountIndex) async throws -> TransparentAddress {
if let error = getTransparentAddressAccountIndexThrowableError {
func getTransparentAddress(accountUUID: AccountUUID) async throws -> TransparentAddress {
if let error = getTransparentAddressAccountUUIDThrowableError {
throw error
}
getTransparentAddressAccountIndexCallsCount += 1
getTransparentAddressAccountIndexReceivedAccountIndex = accountIndex
if let closure = getTransparentAddressAccountIndexClosure {
return try await closure(accountIndex)
getTransparentAddressAccountUUIDCallsCount += 1
getTransparentAddressAccountUUIDReceivedAccountUUID = accountUUID
if let closure = getTransparentAddressAccountUUIDClosure {
return try await closure(accountUUID)
} else {
return getTransparentAddressAccountIndexReturnValue
return getTransparentAddressAccountUUIDReturnValue
}
}
// MARK: - proposeTransfer
var proposeTransferAccountIndexRecipientAmountMemoThrowableError: Error?
var proposeTransferAccountIndexRecipientAmountMemoCallsCount = 0
var proposeTransferAccountIndexRecipientAmountMemoCalled: Bool {
return proposeTransferAccountIndexRecipientAmountMemoCallsCount > 0
var proposeTransferAccountUUIDRecipientAmountMemoThrowableError: Error?
var proposeTransferAccountUUIDRecipientAmountMemoCallsCount = 0
var proposeTransferAccountUUIDRecipientAmountMemoCalled: Bool {
return proposeTransferAccountUUIDRecipientAmountMemoCallsCount > 0
}
var proposeTransferAccountIndexRecipientAmountMemoReceivedArguments: (accountIndex: Zip32AccountIndex, recipient: Recipient, amount: Zatoshi, memo: Memo?)?
var proposeTransferAccountIndexRecipientAmountMemoReturnValue: Proposal!
var proposeTransferAccountIndexRecipientAmountMemoClosure: ((Zip32AccountIndex, Recipient, Zatoshi, Memo?) async throws -> Proposal)?
var proposeTransferAccountUUIDRecipientAmountMemoReceivedArguments: (accountUUID: AccountUUID, recipient: Recipient, amount: Zatoshi, memo: Memo?)?
var proposeTransferAccountUUIDRecipientAmountMemoReturnValue: Proposal!
var proposeTransferAccountUUIDRecipientAmountMemoClosure: ((AccountUUID, Recipient, Zatoshi, Memo?) async throws -> Proposal)?
func proposeTransfer(accountIndex: Zip32AccountIndex, recipient: Recipient, amount: Zatoshi, memo: Memo?) async throws -> Proposal {
if let error = proposeTransferAccountIndexRecipientAmountMemoThrowableError {
func proposeTransfer(accountUUID: AccountUUID, recipient: Recipient, amount: Zatoshi, memo: Memo?) async throws -> Proposal {
if let error = proposeTransferAccountUUIDRecipientAmountMemoThrowableError {
throw error
}
proposeTransferAccountIndexRecipientAmountMemoCallsCount += 1
proposeTransferAccountIndexRecipientAmountMemoReceivedArguments = (accountIndex: accountIndex, recipient: recipient, amount: amount, memo: memo)
if let closure = proposeTransferAccountIndexRecipientAmountMemoClosure {
return try await closure(accountIndex, recipient, amount, memo)
proposeTransferAccountUUIDRecipientAmountMemoCallsCount += 1
proposeTransferAccountUUIDRecipientAmountMemoReceivedArguments = (accountUUID: accountUUID, recipient: recipient, amount: amount, memo: memo)
if let closure = proposeTransferAccountUUIDRecipientAmountMemoClosure {
return try await closure(accountUUID, recipient, amount, memo)
} else {
return proposeTransferAccountIndexRecipientAmountMemoReturnValue
return proposeTransferAccountUUIDRecipientAmountMemoReturnValue
}
}
// MARK: - proposeShielding
var proposeShieldingAccountIndexShieldingThresholdMemoTransparentReceiverThrowableError: Error?
var proposeShieldingAccountIndexShieldingThresholdMemoTransparentReceiverCallsCount = 0
var proposeShieldingAccountIndexShieldingThresholdMemoTransparentReceiverCalled: Bool {
return proposeShieldingAccountIndexShieldingThresholdMemoTransparentReceiverCallsCount > 0
var proposeShieldingAccountUUIDShieldingThresholdMemoTransparentReceiverThrowableError: Error?
var proposeShieldingAccountUUIDShieldingThresholdMemoTransparentReceiverCallsCount = 0
var proposeShieldingAccountUUIDShieldingThresholdMemoTransparentReceiverCalled: Bool {
return proposeShieldingAccountUUIDShieldingThresholdMemoTransparentReceiverCallsCount > 0
}
var proposeShieldingAccountIndexShieldingThresholdMemoTransparentReceiverReceivedArguments: (accountIndex: Zip32AccountIndex, shieldingThreshold: Zatoshi, memo: Memo, transparentReceiver: TransparentAddress?)?
var proposeShieldingAccountIndexShieldingThresholdMemoTransparentReceiverReturnValue: Proposal?
var proposeShieldingAccountIndexShieldingThresholdMemoTransparentReceiverClosure: ((Zip32AccountIndex, Zatoshi, Memo, TransparentAddress?) async throws -> Proposal?)?
var proposeShieldingAccountUUIDShieldingThresholdMemoTransparentReceiverReceivedArguments: (accountUUID: AccountUUID, shieldingThreshold: Zatoshi, memo: Memo, transparentReceiver: TransparentAddress?)?
var proposeShieldingAccountUUIDShieldingThresholdMemoTransparentReceiverReturnValue: Proposal?
var proposeShieldingAccountUUIDShieldingThresholdMemoTransparentReceiverClosure: ((AccountUUID, Zatoshi, Memo, TransparentAddress?) async throws -> Proposal?)?
func proposeShielding(accountIndex: Zip32AccountIndex, shieldingThreshold: Zatoshi, memo: Memo, transparentReceiver: TransparentAddress?) async throws -> Proposal? {
if let error = proposeShieldingAccountIndexShieldingThresholdMemoTransparentReceiverThrowableError {
func proposeShielding(accountUUID: AccountUUID, shieldingThreshold: Zatoshi, memo: Memo, transparentReceiver: TransparentAddress?) async throws -> Proposal? {
if let error = proposeShieldingAccountUUIDShieldingThresholdMemoTransparentReceiverThrowableError {
throw error
}
proposeShieldingAccountIndexShieldingThresholdMemoTransparentReceiverCallsCount += 1
proposeShieldingAccountIndexShieldingThresholdMemoTransparentReceiverReceivedArguments = (accountIndex: accountIndex, shieldingThreshold: shieldingThreshold, memo: memo, transparentReceiver: transparentReceiver)
if let closure = proposeShieldingAccountIndexShieldingThresholdMemoTransparentReceiverClosure {
return try await closure(accountIndex, shieldingThreshold, memo, transparentReceiver)
proposeShieldingAccountUUIDShieldingThresholdMemoTransparentReceiverCallsCount += 1
proposeShieldingAccountUUIDShieldingThresholdMemoTransparentReceiverReceivedArguments = (accountUUID: accountUUID, shieldingThreshold: shieldingThreshold, memo: memo, transparentReceiver: transparentReceiver)
if let closure = proposeShieldingAccountUUIDShieldingThresholdMemoTransparentReceiverClosure {
return try await closure(accountUUID, shieldingThreshold, memo, transparentReceiver)
} else {
return proposeShieldingAccountIndexShieldingThresholdMemoTransparentReceiverReturnValue
return proposeShieldingAccountUUIDShieldingThresholdMemoTransparentReceiverReturnValue
}
}
@ -1548,75 +1548,99 @@ class SynchronizerMock: Synchronizer {
}
}
// MARK: - sendToAddress
var sendToAddressSpendingKeyZatoshiToAddressMemoThrowableError: Error?
var sendToAddressSpendingKeyZatoshiToAddressMemoCallsCount = 0
var sendToAddressSpendingKeyZatoshiToAddressMemoCalled: Bool {
return sendToAddressSpendingKeyZatoshiToAddressMemoCallsCount > 0
}
var sendToAddressSpendingKeyZatoshiToAddressMemoReceivedArguments: (spendingKey: UnifiedSpendingKey, zatoshi: Zatoshi, toAddress: Recipient, memo: Memo?)?
var sendToAddressSpendingKeyZatoshiToAddressMemoReturnValue: ZcashTransaction.Overview!
var sendToAddressSpendingKeyZatoshiToAddressMemoClosure: ((UnifiedSpendingKey, Zatoshi, Recipient, Memo?) async throws -> ZcashTransaction.Overview)?
func sendToAddress(spendingKey: UnifiedSpendingKey, zatoshi: Zatoshi, toAddress: Recipient, memo: Memo?) async throws -> ZcashTransaction.Overview {
if let error = sendToAddressSpendingKeyZatoshiToAddressMemoThrowableError {
throw error
}
sendToAddressSpendingKeyZatoshiToAddressMemoCallsCount += 1
sendToAddressSpendingKeyZatoshiToAddressMemoReceivedArguments = (spendingKey: spendingKey, zatoshi: zatoshi, toAddress: toAddress, memo: memo)
if let closure = sendToAddressSpendingKeyZatoshiToAddressMemoClosure {
return try await closure(spendingKey, zatoshi, toAddress, memo)
} else {
return sendToAddressSpendingKeyZatoshiToAddressMemoReturnValue
}
}
// MARK: - proposefulfillingPaymentURI
var proposefulfillingPaymentURIAccountIndexThrowableError: Error?
var proposefulfillingPaymentURIAccountIndexCallsCount = 0
var proposefulfillingPaymentURIAccountIndexCalled: Bool {
return proposefulfillingPaymentURIAccountIndexCallsCount > 0
var proposefulfillingPaymentURIAccountUUIDThrowableError: Error?
var proposefulfillingPaymentURIAccountUUIDCallsCount = 0
var proposefulfillingPaymentURIAccountUUIDCalled: Bool {
return proposefulfillingPaymentURIAccountUUIDCallsCount > 0
}
var proposefulfillingPaymentURIAccountIndexReceivedArguments: (uri: String, accountIndex: Zip32AccountIndex)?
var proposefulfillingPaymentURIAccountIndexReturnValue: Proposal!
var proposefulfillingPaymentURIAccountIndexClosure: ((String, Zip32AccountIndex) async throws -> Proposal)?
var proposefulfillingPaymentURIAccountUUIDReceivedArguments: (uri: String, accountUUID: AccountUUID)?
var proposefulfillingPaymentURIAccountUUIDReturnValue: Proposal!
var proposefulfillingPaymentURIAccountUUIDClosure: ((String, AccountUUID) async throws -> Proposal)?
func proposefulfillingPaymentURI(_ uri: String, accountIndex: Zip32AccountIndex) async throws -> Proposal {
if let error = proposefulfillingPaymentURIAccountIndexThrowableError {
func proposefulfillingPaymentURI(_ uri: String, accountUUID: AccountUUID) async throws -> Proposal {
if let error = proposefulfillingPaymentURIAccountUUIDThrowableError {
throw error
}
proposefulfillingPaymentURIAccountIndexCallsCount += 1
proposefulfillingPaymentURIAccountIndexReceivedArguments = (uri: uri, accountIndex: accountIndex)
if let closure = proposefulfillingPaymentURIAccountIndexClosure {
return try await closure(uri, accountIndex)
proposefulfillingPaymentURIAccountUUIDCallsCount += 1
proposefulfillingPaymentURIAccountUUIDReceivedArguments = (uri: uri, accountUUID: accountUUID)
if let closure = proposefulfillingPaymentURIAccountUUIDClosure {
return try await closure(uri, accountUUID)
} else {
return proposefulfillingPaymentURIAccountIndexReturnValue
return proposefulfillingPaymentURIAccountUUIDReturnValue
}
}
// MARK: - shieldFunds
// MARK: - createPCZTFromProposal
var shieldFundsSpendingKeyMemoShieldingThresholdThrowableError: Error?
var shieldFundsSpendingKeyMemoShieldingThresholdCallsCount = 0
var shieldFundsSpendingKeyMemoShieldingThresholdCalled: Bool {
return shieldFundsSpendingKeyMemoShieldingThresholdCallsCount > 0
var createPCZTFromProposalAccountUUIDProposalThrowableError: Error?
var createPCZTFromProposalAccountUUIDProposalCallsCount = 0
var createPCZTFromProposalAccountUUIDProposalCalled: Bool {
return createPCZTFromProposalAccountUUIDProposalCallsCount > 0
}
var shieldFundsSpendingKeyMemoShieldingThresholdReceivedArguments: (spendingKey: UnifiedSpendingKey, memo: Memo, shieldingThreshold: Zatoshi)?
var shieldFundsSpendingKeyMemoShieldingThresholdReturnValue: ZcashTransaction.Overview!
var shieldFundsSpendingKeyMemoShieldingThresholdClosure: ((UnifiedSpendingKey, Memo, Zatoshi) async throws -> ZcashTransaction.Overview)?
var createPCZTFromProposalAccountUUIDProposalReceivedArguments: (accountUUID: AccountUUID, proposal: Proposal)?
var createPCZTFromProposalAccountUUIDProposalReturnValue: Pczt!
var createPCZTFromProposalAccountUUIDProposalClosure: ((AccountUUID, Proposal) async throws -> Pczt)?
func shieldFunds(spendingKey: UnifiedSpendingKey, memo: Memo, shieldingThreshold: Zatoshi) async throws -> ZcashTransaction.Overview {
if let error = shieldFundsSpendingKeyMemoShieldingThresholdThrowableError {
func createPCZTFromProposal(accountUUID: AccountUUID, proposal: Proposal) async throws -> Pczt {
if let error = createPCZTFromProposalAccountUUIDProposalThrowableError {
throw error
}
shieldFundsSpendingKeyMemoShieldingThresholdCallsCount += 1
shieldFundsSpendingKeyMemoShieldingThresholdReceivedArguments = (spendingKey: spendingKey, memo: memo, shieldingThreshold: shieldingThreshold)
if let closure = shieldFundsSpendingKeyMemoShieldingThresholdClosure {
return try await closure(spendingKey, memo, shieldingThreshold)
createPCZTFromProposalAccountUUIDProposalCallsCount += 1
createPCZTFromProposalAccountUUIDProposalReceivedArguments = (accountUUID: accountUUID, proposal: proposal)
if let closure = createPCZTFromProposalAccountUUIDProposalClosure {
return try await closure(accountUUID, proposal)
} else {
return shieldFundsSpendingKeyMemoShieldingThresholdReturnValue
return createPCZTFromProposalAccountUUIDProposalReturnValue
}
}
// MARK: - addProofsToPCZT
var addProofsToPCZTPcztThrowableError: Error?
var addProofsToPCZTPcztCallsCount = 0
var addProofsToPCZTPcztCalled: Bool {
return addProofsToPCZTPcztCallsCount > 0
}
var addProofsToPCZTPcztReceivedPczt: Pczt?
var addProofsToPCZTPcztReturnValue: Pczt!
var addProofsToPCZTPcztClosure: ((Pczt) async throws -> Pczt)?
func addProofsToPCZT(pczt: Pczt) async throws -> Pczt {
if let error = addProofsToPCZTPcztThrowableError {
throw error
}
addProofsToPCZTPcztCallsCount += 1
addProofsToPCZTPcztReceivedPczt = pczt
if let closure = addProofsToPCZTPcztClosure {
return try await closure(pczt)
} else {
return addProofsToPCZTPcztReturnValue
}
}
// MARK: - createTransactionFromPCZT
var createTransactionFromPCZTPcztWithProofsPcztWithSigsThrowableError: Error?
var createTransactionFromPCZTPcztWithProofsPcztWithSigsCallsCount = 0
var createTransactionFromPCZTPcztWithProofsPcztWithSigsCalled: Bool {
return createTransactionFromPCZTPcztWithProofsPcztWithSigsCallsCount > 0
}
var createTransactionFromPCZTPcztWithProofsPcztWithSigsReceivedArguments: (pcztWithProofs: Pczt, pcztWithSigs: Pczt)?
var createTransactionFromPCZTPcztWithProofsPcztWithSigsReturnValue: AsyncThrowingStream<TransactionSubmitResult, Error>!
var createTransactionFromPCZTPcztWithProofsPcztWithSigsClosure: ((Pczt, Pczt) async throws -> AsyncThrowingStream<TransactionSubmitResult, Error>)?
func createTransactionFromPCZT(pcztWithProofs: Pczt, pcztWithSigs: Pczt) async throws -> AsyncThrowingStream<TransactionSubmitResult, Error> {
if let error = createTransactionFromPCZTPcztWithProofsPcztWithSigsThrowableError {
throw error
}
createTransactionFromPCZTPcztWithProofsPcztWithSigsCallsCount += 1
createTransactionFromPCZTPcztWithProofsPcztWithSigsReceivedArguments = (pcztWithProofs: pcztWithProofs, pcztWithSigs: pcztWithSigs)
if let closure = createTransactionFromPCZTPcztWithProofsPcztWithSigsClosure {
return try await closure(pcztWithProofs, pcztWithSigs)
} else {
return createTransactionFromPCZTPcztWithProofsPcztWithSigsReturnValue
}
}
@ -1805,10 +1829,10 @@ class SynchronizerMock: Synchronizer {
var getAccountsBalancesCalled: Bool {
return getAccountsBalancesCallsCount > 0
}
var getAccountsBalancesReturnValue: [Zip32AccountIndex: AccountBalance]!
var getAccountsBalancesClosure: (() async throws -> [Zip32AccountIndex: AccountBalance])?
var getAccountsBalancesReturnValue: [AccountUUID: AccountBalance]!
var getAccountsBalancesClosure: (() async throws -> [AccountUUID: AccountBalance])?
func getAccountsBalances() async throws -> [Zip32AccountIndex: AccountBalance] {
func getAccountsBalances() async throws -> [AccountUUID: AccountBalance] {
if let error = getAccountsBalancesThrowableError {
throw error
}
@ -1833,6 +1857,52 @@ class SynchronizerMock: Synchronizer {
refreshExchangeRateUSDClosure!()
}
// MARK: - listAccounts
var listAccountsThrowableError: Error?
var listAccountsCallsCount = 0
var listAccountsCalled: Bool {
return listAccountsCallsCount > 0
}
var listAccountsReturnValue: [Account]!
var listAccountsClosure: (() async throws -> [Account])?
func listAccounts() async throws -> [Account] {
if let error = listAccountsThrowableError {
throw error
}
listAccountsCallsCount += 1
if let closure = listAccountsClosure {
return try await closure()
} else {
return listAccountsReturnValue
}
}
// MARK: - importAccount
var importAccountUfvkSeedFingerprintZip32AccountIndexPurposeNameKeySourceThrowableError: Error?
var importAccountUfvkSeedFingerprintZip32AccountIndexPurposeNameKeySourceCallsCount = 0
var importAccountUfvkSeedFingerprintZip32AccountIndexPurposeNameKeySourceCalled: Bool {
return importAccountUfvkSeedFingerprintZip32AccountIndexPurposeNameKeySourceCallsCount > 0
}
var importAccountUfvkSeedFingerprintZip32AccountIndexPurposeNameKeySourceReceivedArguments: (ufvk: String, seedFingerprint: [UInt8]?, zip32AccountIndex: Zip32AccountIndex?, purpose: AccountPurpose, name: String, keySource: String?)?
var importAccountUfvkSeedFingerprintZip32AccountIndexPurposeNameKeySourceReturnValue: AccountUUID!
var importAccountUfvkSeedFingerprintZip32AccountIndexPurposeNameKeySourceClosure: ((String, [UInt8]?, Zip32AccountIndex?, AccountPurpose, String, String?) async throws -> AccountUUID)?
func importAccount(ufvk: String, seedFingerprint: [UInt8]?, zip32AccountIndex: Zip32AccountIndex?, purpose: AccountPurpose, name: String, keySource: String?) async throws -> AccountUUID {
if let error = importAccountUfvkSeedFingerprintZip32AccountIndexPurposeNameKeySourceThrowableError {
throw error
}
importAccountUfvkSeedFingerprintZip32AccountIndexPurposeNameKeySourceCallsCount += 1
importAccountUfvkSeedFingerprintZip32AccountIndexPurposeNameKeySourceReceivedArguments = (ufvk: ufvk, seedFingerprint: seedFingerprint, zip32AccountIndex: zip32AccountIndex, purpose: purpose, name: name, keySource: keySource)
if let closure = importAccountUfvkSeedFingerprintZip32AccountIndexPurposeNameKeySourceClosure {
return try await closure(ufvk, seedFingerprint, zip32AccountIndex, purpose, name, keySource)
} else {
return importAccountUfvkSeedFingerprintZip32AccountIndexPurposeNameKeySourceReturnValue
}
}
// MARK: - rewind
var rewindCallsCount = 0
@ -2423,10 +2493,10 @@ class ZcashRustBackendWeldingMock: ZcashRustBackendWelding {
var listAccountsCalled: Bool {
return listAccountsCallsCount > 0
}
var listAccountsReturnValue: [Zip32AccountIndex]!
var listAccountsClosure: (() async throws -> [Zip32AccountIndex])?
var listAccountsReturnValue: [Account]!
var listAccountsClosure: (() async throws -> [Account])?
func listAccounts() async throws -> [Zip32AccountIndex] {
func listAccounts() async throws -> [Account] {
if let error = listAccountsThrowableError {
throw error
}
@ -2438,27 +2508,51 @@ class ZcashRustBackendWeldingMock: ZcashRustBackendWelding {
}
}
// MARK: - createAccount
// MARK: - importAccount
var createAccountSeedTreeStateRecoverUntilThrowableError: Error?
var createAccountSeedTreeStateRecoverUntilCallsCount = 0
var createAccountSeedTreeStateRecoverUntilCalled: Bool {
return createAccountSeedTreeStateRecoverUntilCallsCount > 0
var importAccountUfvkSeedFingerprintZip32AccountIndexTreeStateRecoverUntilPurposeNameKeySourceThrowableError: Error?
var importAccountUfvkSeedFingerprintZip32AccountIndexTreeStateRecoverUntilPurposeNameKeySourceCallsCount = 0
var importAccountUfvkSeedFingerprintZip32AccountIndexTreeStateRecoverUntilPurposeNameKeySourceCalled: Bool {
return importAccountUfvkSeedFingerprintZip32AccountIndexTreeStateRecoverUntilPurposeNameKeySourceCallsCount > 0
}
var createAccountSeedTreeStateRecoverUntilReceivedArguments: (seed: [UInt8], treeState: TreeState, recoverUntil: UInt32?)?
var createAccountSeedTreeStateRecoverUntilReturnValue: UnifiedSpendingKey!
var createAccountSeedTreeStateRecoverUntilClosure: (([UInt8], TreeState, UInt32?) async throws -> UnifiedSpendingKey)?
var importAccountUfvkSeedFingerprintZip32AccountIndexTreeStateRecoverUntilPurposeNameKeySourceReceivedArguments: (ufvk: String, seedFingerprint: [UInt8]?, zip32AccountIndex: Zip32AccountIndex?, treeState: TreeState, recoverUntil: UInt32?, purpose: AccountPurpose, name: String, keySource: String?)?
var importAccountUfvkSeedFingerprintZip32AccountIndexTreeStateRecoverUntilPurposeNameKeySourceReturnValue: AccountUUID!
var importAccountUfvkSeedFingerprintZip32AccountIndexTreeStateRecoverUntilPurposeNameKeySourceClosure: ((String, [UInt8]?, Zip32AccountIndex?, TreeState, UInt32?, AccountPurpose, String, String?) async throws -> AccountUUID)?
func createAccount(seed: [UInt8], treeState: TreeState, recoverUntil: UInt32?) async throws -> UnifiedSpendingKey {
if let error = createAccountSeedTreeStateRecoverUntilThrowableError {
func importAccount(ufvk: String, seedFingerprint: [UInt8]?, zip32AccountIndex: Zip32AccountIndex?, treeState: TreeState, recoverUntil: UInt32?, purpose: AccountPurpose, name: String, keySource: String?) async throws -> AccountUUID {
if let error = importAccountUfvkSeedFingerprintZip32AccountIndexTreeStateRecoverUntilPurposeNameKeySourceThrowableError {
throw error
}
createAccountSeedTreeStateRecoverUntilCallsCount += 1
createAccountSeedTreeStateRecoverUntilReceivedArguments = (seed: seed, treeState: treeState, recoverUntil: recoverUntil)
if let closure = createAccountSeedTreeStateRecoverUntilClosure {
return try await closure(seed, treeState, recoverUntil)
importAccountUfvkSeedFingerprintZip32AccountIndexTreeStateRecoverUntilPurposeNameKeySourceCallsCount += 1
importAccountUfvkSeedFingerprintZip32AccountIndexTreeStateRecoverUntilPurposeNameKeySourceReceivedArguments = (ufvk: ufvk, seedFingerprint: seedFingerprint, zip32AccountIndex: zip32AccountIndex, treeState: treeState, recoverUntil: recoverUntil, purpose: purpose, name: name, keySource: keySource)
if let closure = importAccountUfvkSeedFingerprintZip32AccountIndexTreeStateRecoverUntilPurposeNameKeySourceClosure {
return try await closure(ufvk, seedFingerprint, zip32AccountIndex, treeState, recoverUntil, purpose, name, keySource)
} else {
return createAccountSeedTreeStateRecoverUntilReturnValue
return importAccountUfvkSeedFingerprintZip32AccountIndexTreeStateRecoverUntilPurposeNameKeySourceReturnValue
}
}
// MARK: - createAccount
var createAccountSeedTreeStateRecoverUntilNameKeySourceThrowableError: Error?
var createAccountSeedTreeStateRecoverUntilNameKeySourceCallsCount = 0
var createAccountSeedTreeStateRecoverUntilNameKeySourceCalled: Bool {
return createAccountSeedTreeStateRecoverUntilNameKeySourceCallsCount > 0
}
var createAccountSeedTreeStateRecoverUntilNameKeySourceReceivedArguments: (seed: [UInt8], treeState: TreeState, recoverUntil: UInt32?, name: String, keySource: String?)?
var createAccountSeedTreeStateRecoverUntilNameKeySourceReturnValue: UnifiedSpendingKey!
var createAccountSeedTreeStateRecoverUntilNameKeySourceClosure: (([UInt8], TreeState, UInt32?, String, String?) async throws -> UnifiedSpendingKey)?
func createAccount(seed: [UInt8], treeState: TreeState, recoverUntil: UInt32?, name: String, keySource: String?) async throws -> UnifiedSpendingKey {
if let error = createAccountSeedTreeStateRecoverUntilNameKeySourceThrowableError {
throw error
}
createAccountSeedTreeStateRecoverUntilNameKeySourceCallsCount += 1
createAccountSeedTreeStateRecoverUntilNameKeySourceReceivedArguments = (seed: seed, treeState: treeState, recoverUntil: recoverUntil, name: name, keySource: keySource)
if let closure = createAccountSeedTreeStateRecoverUntilNameKeySourceClosure {
return try await closure(seed, treeState, recoverUntil, name, keySource)
} else {
return createAccountSeedTreeStateRecoverUntilNameKeySourceReturnValue
}
}
@ -2507,49 +2601,49 @@ class ZcashRustBackendWeldingMock: ZcashRustBackendWelding {
// MARK: - getCurrentAddress
var getCurrentAddressAccountIndexThrowableError: Error?
var getCurrentAddressAccountIndexCallsCount = 0
var getCurrentAddressAccountIndexCalled: Bool {
return getCurrentAddressAccountIndexCallsCount > 0
var getCurrentAddressAccountUUIDThrowableError: Error?
var getCurrentAddressAccountUUIDCallsCount = 0
var getCurrentAddressAccountUUIDCalled: Bool {
return getCurrentAddressAccountUUIDCallsCount > 0
}
var getCurrentAddressAccountIndexReceivedAccountIndex: Zip32AccountIndex?
var getCurrentAddressAccountIndexReturnValue: UnifiedAddress!
var getCurrentAddressAccountIndexClosure: ((Zip32AccountIndex) async throws -> UnifiedAddress)?
var getCurrentAddressAccountUUIDReceivedAccountUUID: AccountUUID?
var getCurrentAddressAccountUUIDReturnValue: UnifiedAddress!
var getCurrentAddressAccountUUIDClosure: ((AccountUUID) async throws -> UnifiedAddress)?
func getCurrentAddress(accountIndex: Zip32AccountIndex) async throws -> UnifiedAddress {
if let error = getCurrentAddressAccountIndexThrowableError {
func getCurrentAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress {
if let error = getCurrentAddressAccountUUIDThrowableError {
throw error
}
getCurrentAddressAccountIndexCallsCount += 1
getCurrentAddressAccountIndexReceivedAccountIndex = accountIndex
if let closure = getCurrentAddressAccountIndexClosure {
return try await closure(accountIndex)
getCurrentAddressAccountUUIDCallsCount += 1
getCurrentAddressAccountUUIDReceivedAccountUUID = accountUUID
if let closure = getCurrentAddressAccountUUIDClosure {
return try await closure(accountUUID)
} else {
return getCurrentAddressAccountIndexReturnValue
return getCurrentAddressAccountUUIDReturnValue
}
}
// MARK: - getNextAvailableAddress
var getNextAvailableAddressAccountIndexThrowableError: Error?
var getNextAvailableAddressAccountIndexCallsCount = 0
var getNextAvailableAddressAccountIndexCalled: Bool {
return getNextAvailableAddressAccountIndexCallsCount > 0
var getNextAvailableAddressAccountUUIDThrowableError: Error?
var getNextAvailableAddressAccountUUIDCallsCount = 0
var getNextAvailableAddressAccountUUIDCalled: Bool {
return getNextAvailableAddressAccountUUIDCallsCount > 0
}
var getNextAvailableAddressAccountIndexReceivedAccountIndex: Zip32AccountIndex?
var getNextAvailableAddressAccountIndexReturnValue: UnifiedAddress!
var getNextAvailableAddressAccountIndexClosure: ((Zip32AccountIndex) async throws -> UnifiedAddress)?
var getNextAvailableAddressAccountUUIDReceivedAccountUUID: AccountUUID?
var getNextAvailableAddressAccountUUIDReturnValue: UnifiedAddress!
var getNextAvailableAddressAccountUUIDClosure: ((AccountUUID) async throws -> UnifiedAddress)?
func getNextAvailableAddress(accountIndex: Zip32AccountIndex) async throws -> UnifiedAddress {
if let error = getNextAvailableAddressAccountIndexThrowableError {
func getNextAvailableAddress(accountUUID: AccountUUID) async throws -> UnifiedAddress {
if let error = getNextAvailableAddressAccountUUIDThrowableError {
throw error
}
getNextAvailableAddressAccountIndexCallsCount += 1
getNextAvailableAddressAccountIndexReceivedAccountIndex = accountIndex
if let closure = getNextAvailableAddressAccountIndexClosure {
return try await closure(accountIndex)
getNextAvailableAddressAccountUUIDCallsCount += 1
getNextAvailableAddressAccountUUIDReceivedAccountUUID = accountUUID
if let closure = getNextAvailableAddressAccountUUIDClosure {
return try await closure(accountUUID)
} else {
return getNextAvailableAddressAccountIndexReturnValue
return getNextAvailableAddressAccountUUIDReturnValue
}
}
@ -2579,25 +2673,25 @@ class ZcashRustBackendWeldingMock: ZcashRustBackendWelding {
// MARK: - getTransparentBalance
var getTransparentBalanceAccountIndexThrowableError: Error?
var getTransparentBalanceAccountIndexCallsCount = 0
var getTransparentBalanceAccountIndexCalled: Bool {
return getTransparentBalanceAccountIndexCallsCount > 0
var getTransparentBalanceAccountUUIDThrowableError: Error?
var getTransparentBalanceAccountUUIDCallsCount = 0
var getTransparentBalanceAccountUUIDCalled: Bool {
return getTransparentBalanceAccountUUIDCallsCount > 0
}
var getTransparentBalanceAccountIndexReceivedAccountIndex: Zip32AccountIndex?
var getTransparentBalanceAccountIndexReturnValue: Int64!
var getTransparentBalanceAccountIndexClosure: ((Zip32AccountIndex) async throws -> Int64)?
var getTransparentBalanceAccountUUIDReceivedAccountUUID: AccountUUID?
var getTransparentBalanceAccountUUIDReturnValue: Int64!
var getTransparentBalanceAccountUUIDClosure: ((AccountUUID) async throws -> Int64)?
func getTransparentBalance(accountIndex: Zip32AccountIndex) async throws -> Int64 {
if let error = getTransparentBalanceAccountIndexThrowableError {
func getTransparentBalance(accountUUID: AccountUUID) async throws -> Int64 {
if let error = getTransparentBalanceAccountUUIDThrowableError {
throw error
}
getTransparentBalanceAccountIndexCallsCount += 1
getTransparentBalanceAccountIndexReceivedAccountIndex = accountIndex
if let closure = getTransparentBalanceAccountIndexClosure {
return try await closure(accountIndex)
getTransparentBalanceAccountUUIDCallsCount += 1
getTransparentBalanceAccountUUIDReceivedAccountUUID = accountUUID
if let closure = getTransparentBalanceAccountUUIDClosure {
return try await closure(accountUUID)
} else {
return getTransparentBalanceAccountIndexReturnValue
return getTransparentBalanceAccountUUIDReturnValue
}
}
@ -2627,49 +2721,49 @@ class ZcashRustBackendWeldingMock: ZcashRustBackendWelding {
// MARK: - listTransparentReceivers
var listTransparentReceiversAccountIndexThrowableError: Error?
var listTransparentReceiversAccountIndexCallsCount = 0
var listTransparentReceiversAccountIndexCalled: Bool {
return listTransparentReceiversAccountIndexCallsCount > 0
var listTransparentReceiversAccountUUIDThrowableError: Error?
var listTransparentReceiversAccountUUIDCallsCount = 0
var listTransparentReceiversAccountUUIDCalled: Bool {
return listTransparentReceiversAccountUUIDCallsCount > 0
}
var listTransparentReceiversAccountIndexReceivedAccountIndex: Zip32AccountIndex?
var listTransparentReceiversAccountIndexReturnValue: [TransparentAddress]!
var listTransparentReceiversAccountIndexClosure: ((Zip32AccountIndex) async throws -> [TransparentAddress])?
var listTransparentReceiversAccountUUIDReceivedAccountUUID: AccountUUID?
var listTransparentReceiversAccountUUIDReturnValue: [TransparentAddress]!
var listTransparentReceiversAccountUUIDClosure: ((AccountUUID) async throws -> [TransparentAddress])?
func listTransparentReceivers(accountIndex: Zip32AccountIndex) async throws -> [TransparentAddress] {
if let error = listTransparentReceiversAccountIndexThrowableError {
func listTransparentReceivers(accountUUID: AccountUUID) async throws -> [TransparentAddress] {
if let error = listTransparentReceiversAccountUUIDThrowableError {
throw error
}
listTransparentReceiversAccountIndexCallsCount += 1
listTransparentReceiversAccountIndexReceivedAccountIndex = accountIndex
if let closure = listTransparentReceiversAccountIndexClosure {
return try await closure(accountIndex)
listTransparentReceiversAccountUUIDCallsCount += 1
listTransparentReceiversAccountUUIDReceivedAccountUUID = accountUUID
if let closure = listTransparentReceiversAccountUUIDClosure {
return try await closure(accountUUID)
} else {
return listTransparentReceiversAccountIndexReturnValue
return listTransparentReceiversAccountUUIDReturnValue
}
}
// MARK: - getVerifiedTransparentBalance
var getVerifiedTransparentBalanceAccountIndexThrowableError: Error?
var getVerifiedTransparentBalanceAccountIndexCallsCount = 0
var getVerifiedTransparentBalanceAccountIndexCalled: Bool {
return getVerifiedTransparentBalanceAccountIndexCallsCount > 0
var getVerifiedTransparentBalanceAccountUUIDThrowableError: Error?
var getVerifiedTransparentBalanceAccountUUIDCallsCount = 0
var getVerifiedTransparentBalanceAccountUUIDCalled: Bool {
return getVerifiedTransparentBalanceAccountUUIDCallsCount > 0
}
var getVerifiedTransparentBalanceAccountIndexReceivedAccountIndex: Zip32AccountIndex?
var getVerifiedTransparentBalanceAccountIndexReturnValue: Int64!
var getVerifiedTransparentBalanceAccountIndexClosure: ((Zip32AccountIndex) async throws -> Int64)?
var getVerifiedTransparentBalanceAccountUUIDReceivedAccountUUID: AccountUUID?
var getVerifiedTransparentBalanceAccountUUIDReturnValue: Int64!
var getVerifiedTransparentBalanceAccountUUIDClosure: ((AccountUUID) async throws -> Int64)?
func getVerifiedTransparentBalance(accountIndex: Zip32AccountIndex) async throws -> Int64 {
if let error = getVerifiedTransparentBalanceAccountIndexThrowableError {
func getVerifiedTransparentBalance(accountUUID: AccountUUID) async throws -> Int64 {
if let error = getVerifiedTransparentBalanceAccountUUIDThrowableError {
throw error
}
getVerifiedTransparentBalanceAccountIndexCallsCount += 1
getVerifiedTransparentBalanceAccountIndexReceivedAccountIndex = accountIndex
if let closure = getVerifiedTransparentBalanceAccountIndexClosure {
return try await closure(accountIndex)
getVerifiedTransparentBalanceAccountUUIDCallsCount += 1
getVerifiedTransparentBalanceAccountUUIDReceivedAccountUUID = accountUUID
if let closure = getVerifiedTransparentBalanceAccountUUIDClosure {
return try await closure(accountUUID)
} else {
return getVerifiedTransparentBalanceAccountIndexReturnValue
return getVerifiedTransparentBalanceAccountUUIDReturnValue
}
}
@ -2906,73 +3000,73 @@ class ZcashRustBackendWeldingMock: ZcashRustBackendWelding {
// MARK: - proposeTransfer
var proposeTransferAccountIndexToValueMemoThrowableError: Error?
var proposeTransferAccountIndexToValueMemoCallsCount = 0
var proposeTransferAccountIndexToValueMemoCalled: Bool {
return proposeTransferAccountIndexToValueMemoCallsCount > 0
var proposeTransferAccountUUIDToValueMemoThrowableError: Error?
var proposeTransferAccountUUIDToValueMemoCallsCount = 0
var proposeTransferAccountUUIDToValueMemoCalled: Bool {
return proposeTransferAccountUUIDToValueMemoCallsCount > 0
}
var proposeTransferAccountIndexToValueMemoReceivedArguments: (accountIndex: Zip32AccountIndex, address: String, value: Int64, memo: MemoBytes?)?
var proposeTransferAccountIndexToValueMemoReturnValue: FfiProposal!
var proposeTransferAccountIndexToValueMemoClosure: ((Zip32AccountIndex, String, Int64, MemoBytes?) async throws -> FfiProposal)?
var proposeTransferAccountUUIDToValueMemoReceivedArguments: (accountUUID: AccountUUID, address: String, value: Int64, memo: MemoBytes?)?
var proposeTransferAccountUUIDToValueMemoReturnValue: FfiProposal!
var proposeTransferAccountUUIDToValueMemoClosure: ((AccountUUID, String, Int64, MemoBytes?) async throws -> FfiProposal)?
func proposeTransfer(accountIndex: Zip32AccountIndex, to address: String, value: Int64, memo: MemoBytes?) async throws -> FfiProposal {
if let error = proposeTransferAccountIndexToValueMemoThrowableError {
func proposeTransfer(accountUUID: AccountUUID, to address: String, value: Int64, memo: MemoBytes?) async throws -> FfiProposal {
if let error = proposeTransferAccountUUIDToValueMemoThrowableError {
throw error
}
proposeTransferAccountIndexToValueMemoCallsCount += 1
proposeTransferAccountIndexToValueMemoReceivedArguments = (accountIndex: accountIndex, address: address, value: value, memo: memo)
if let closure = proposeTransferAccountIndexToValueMemoClosure {
return try await closure(accountIndex, address, value, memo)
proposeTransferAccountUUIDToValueMemoCallsCount += 1
proposeTransferAccountUUIDToValueMemoReceivedArguments = (accountUUID: accountUUID, address: address, value: value, memo: memo)
if let closure = proposeTransferAccountUUIDToValueMemoClosure {
return try await closure(accountUUID, address, value, memo)
} else {
return proposeTransferAccountIndexToValueMemoReturnValue
return proposeTransferAccountUUIDToValueMemoReturnValue
}
}
// MARK: - proposeTransferFromURI
var proposeTransferFromURIAccountIndexThrowableError: Error?
var proposeTransferFromURIAccountIndexCallsCount = 0
var proposeTransferFromURIAccountIndexCalled: Bool {
return proposeTransferFromURIAccountIndexCallsCount > 0
var proposeTransferFromURIAccountUUIDThrowableError: Error?
var proposeTransferFromURIAccountUUIDCallsCount = 0
var proposeTransferFromURIAccountUUIDCalled: Bool {
return proposeTransferFromURIAccountUUIDCallsCount > 0
}
var proposeTransferFromURIAccountIndexReceivedArguments: (uri: String, accountIndex: Zip32AccountIndex)?
var proposeTransferFromURIAccountIndexReturnValue: FfiProposal!
var proposeTransferFromURIAccountIndexClosure: ((String, Zip32AccountIndex) async throws -> FfiProposal)?
var proposeTransferFromURIAccountUUIDReceivedArguments: (uri: String, accountUUID: AccountUUID)?
var proposeTransferFromURIAccountUUIDReturnValue: FfiProposal!
var proposeTransferFromURIAccountUUIDClosure: ((String, AccountUUID) async throws -> FfiProposal)?
func proposeTransferFromURI(_ uri: String, accountIndex: Zip32AccountIndex) async throws -> FfiProposal {
if let error = proposeTransferFromURIAccountIndexThrowableError {
func proposeTransferFromURI(_ uri: String, accountUUID: AccountUUID) async throws -> FfiProposal {
if let error = proposeTransferFromURIAccountUUIDThrowableError {
throw error
}
proposeTransferFromURIAccountIndexCallsCount += 1
proposeTransferFromURIAccountIndexReceivedArguments = (uri: uri, accountIndex: accountIndex)
if let closure = proposeTransferFromURIAccountIndexClosure {
return try await closure(uri, accountIndex)
proposeTransferFromURIAccountUUIDCallsCount += 1
proposeTransferFromURIAccountUUIDReceivedArguments = (uri: uri, accountUUID: accountUUID)
if let closure = proposeTransferFromURIAccountUUIDClosure {
return try await closure(uri, accountUUID)
} else {
return proposeTransferFromURIAccountIndexReturnValue
return proposeTransferFromURIAccountUUIDReturnValue
}
}
// MARK: - proposeShielding
var proposeShieldingAccountIndexMemoShieldingThresholdTransparentReceiverThrowableError: Error?
var proposeShieldingAccountIndexMemoShieldingThresholdTransparentReceiverCallsCount = 0
var proposeShieldingAccountIndexMemoShieldingThresholdTransparentReceiverCalled: Bool {
return proposeShieldingAccountIndexMemoShieldingThresholdTransparentReceiverCallsCount > 0
var proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverThrowableError: Error?
var proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverCallsCount = 0
var proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverCalled: Bool {
return proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverCallsCount > 0
}
var proposeShieldingAccountIndexMemoShieldingThresholdTransparentReceiverReceivedArguments: (accountIndex: Zip32AccountIndex, memo: MemoBytes?, shieldingThreshold: Zatoshi, transparentReceiver: String?)?
var proposeShieldingAccountIndexMemoShieldingThresholdTransparentReceiverReturnValue: FfiProposal?
var proposeShieldingAccountIndexMemoShieldingThresholdTransparentReceiverClosure: ((Zip32AccountIndex, MemoBytes?, Zatoshi, String?) async throws -> FfiProposal?)?
var proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverReceivedArguments: (accountUUID: AccountUUID, memo: MemoBytes?, shieldingThreshold: Zatoshi, transparentReceiver: String?)?
var proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverReturnValue: FfiProposal?
var proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverClosure: ((AccountUUID, MemoBytes?, Zatoshi, String?) async throws -> FfiProposal?)?
func proposeShielding(accountIndex: Zip32AccountIndex, memo: MemoBytes?, shieldingThreshold: Zatoshi, transparentReceiver: String?) async throws -> FfiProposal? {
if let error = proposeShieldingAccountIndexMemoShieldingThresholdTransparentReceiverThrowableError {
func proposeShielding(accountUUID: AccountUUID, memo: MemoBytes?, shieldingThreshold: Zatoshi, transparentReceiver: String?) async throws -> FfiProposal? {
if let error = proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverThrowableError {
throw error
}
proposeShieldingAccountIndexMemoShieldingThresholdTransparentReceiverCallsCount += 1
proposeShieldingAccountIndexMemoShieldingThresholdTransparentReceiverReceivedArguments = (accountIndex: accountIndex, memo: memo, shieldingThreshold: shieldingThreshold, transparentReceiver: transparentReceiver)
if let closure = proposeShieldingAccountIndexMemoShieldingThresholdTransparentReceiverClosure {
return try await closure(accountIndex, memo, shieldingThreshold, transparentReceiver)
proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverCallsCount += 1
proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverReceivedArguments = (accountUUID: accountUUID, memo: memo, shieldingThreshold: shieldingThreshold, transparentReceiver: transparentReceiver)
if let closure = proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverClosure {
return try await closure(accountUUID, memo, shieldingThreshold, transparentReceiver)
} else {
return proposeShieldingAccountIndexMemoShieldingThresholdTransparentReceiverReturnValue
return proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverReturnValue
}
}
@ -3000,6 +3094,78 @@ class ZcashRustBackendWeldingMock: ZcashRustBackendWelding {
}
}
// MARK: - createPCZTFromProposal
var createPCZTFromProposalAccountUUIDProposalThrowableError: Error?
var createPCZTFromProposalAccountUUIDProposalCallsCount = 0
var createPCZTFromProposalAccountUUIDProposalCalled: Bool {
return createPCZTFromProposalAccountUUIDProposalCallsCount > 0
}
var createPCZTFromProposalAccountUUIDProposalReceivedArguments: (accountUUID: AccountUUID, proposal: FfiProposal)?
var createPCZTFromProposalAccountUUIDProposalReturnValue: Pczt!
var createPCZTFromProposalAccountUUIDProposalClosure: ((AccountUUID, FfiProposal) async throws -> Pczt)?
func createPCZTFromProposal(accountUUID: AccountUUID, proposal: FfiProposal) async throws -> Pczt {
if let error = createPCZTFromProposalAccountUUIDProposalThrowableError {
throw error
}
createPCZTFromProposalAccountUUIDProposalCallsCount += 1
createPCZTFromProposalAccountUUIDProposalReceivedArguments = (accountUUID: accountUUID, proposal: proposal)
if let closure = createPCZTFromProposalAccountUUIDProposalClosure {
return try await closure(accountUUID, proposal)
} else {
return createPCZTFromProposalAccountUUIDProposalReturnValue
}
}
// MARK: - addProofsToPCZT
var addProofsToPCZTPcztThrowableError: Error?
var addProofsToPCZTPcztCallsCount = 0
var addProofsToPCZTPcztCalled: Bool {
return addProofsToPCZTPcztCallsCount > 0
}
var addProofsToPCZTPcztReceivedPczt: Pczt?
var addProofsToPCZTPcztReturnValue: Pczt!
var addProofsToPCZTPcztClosure: ((Pczt) async throws -> Pczt)?
func addProofsToPCZT(pczt: Pczt) async throws -> Pczt {
if let error = addProofsToPCZTPcztThrowableError {
throw error
}
addProofsToPCZTPcztCallsCount += 1
addProofsToPCZTPcztReceivedPczt = pczt
if let closure = addProofsToPCZTPcztClosure {
return try await closure(pczt)
} else {
return addProofsToPCZTPcztReturnValue
}
}
// MARK: - extractAndStoreTxFromPCZT
var extractAndStoreTxFromPCZTPcztWithProofsPcztWithSigsThrowableError: Error?
var extractAndStoreTxFromPCZTPcztWithProofsPcztWithSigsCallsCount = 0
var extractAndStoreTxFromPCZTPcztWithProofsPcztWithSigsCalled: Bool {
return extractAndStoreTxFromPCZTPcztWithProofsPcztWithSigsCallsCount > 0
}
var extractAndStoreTxFromPCZTPcztWithProofsPcztWithSigsReceivedArguments: (pcztWithProofs: Pczt, pcztWithSigs: Pczt)?
var extractAndStoreTxFromPCZTPcztWithProofsPcztWithSigsReturnValue: Data!
var extractAndStoreTxFromPCZTPcztWithProofsPcztWithSigsClosure: ((Pczt, Pczt) async throws -> Data)?
func extractAndStoreTxFromPCZT(pcztWithProofs: Pczt, pcztWithSigs: Pczt) async throws -> Data {
if let error = extractAndStoreTxFromPCZTPcztWithProofsPcztWithSigsThrowableError {
throw error
}
extractAndStoreTxFromPCZTPcztWithProofsPcztWithSigsCallsCount += 1
extractAndStoreTxFromPCZTPcztWithProofsPcztWithSigsReceivedArguments = (pcztWithProofs: pcztWithProofs, pcztWithSigs: pcztWithSigs)
if let closure = extractAndStoreTxFromPCZTPcztWithProofsPcztWithSigsClosure {
return try await closure(pcztWithProofs, pcztWithSigs)
} else {
return extractAndStoreTxFromPCZTPcztWithProofsPcztWithSigsReturnValue
}
}
// MARK: - consensusBranchIdFor
var consensusBranchIdForHeightThrowableError: Error?

16
Tests/TestUtils/Stubs.swift
View File

@ -74,16 +74,16 @@ class RustBackendMockHelper {
rustBackendMock.latestCachedBlockHeightReturnValue = .empty()
rustBackendMock.initBlockMetadataDbClosure = { }
rustBackendMock.writeBlocksMetadataBlocksClosure = { _ in }
rustBackendMock.getTransparentBalanceAccountReturnValue = 0
rustBackendMock.listTransparentReceiversAccountReturnValue = []
rustBackendMock.getCurrentAddressAccountThrowableError = ZcashError.rustGetCurrentAddress("mocked error")
rustBackendMock.getNextAvailableAddressAccountThrowableError = ZcashError.rustGetNextAvailableAddress("mocked error")
rustBackendMock.createAccountSeedTreeStateRecoverUntilThrowableError = ZcashError.rustInitAccountsTableViewingKeyCotainsNullBytes
rustBackendMock.getTransparentBalanceAccountUUIDReturnValue = 0
rustBackendMock.listTransparentReceiversAccountUUIDReturnValue = []
rustBackendMock.getCurrentAddressAccountUUIDThrowableError = ZcashError.rustGetCurrentAddress("mocked error")
rustBackendMock.getNextAvailableAddressAccountUUIDThrowableError = ZcashError.rustGetNextAvailableAddress("mocked error")
rustBackendMock.createAccountSeedTreeStateRecoverUntilNameKeySourceThrowableError = ZcashError.rustInitAccountsTableViewingKeyCotainsNullBytes
rustBackendMock.getMemoTxIdOutputPoolOutputIndexReturnValue = nil
rustBackendMock.initDataDbSeedReturnValue = .seedRequired
rustBackendMock.putUnspentTransparentOutputTxidIndexScriptValueHeightClosure = { _, _, _, _, _ in }
rustBackendMock.proposeTransferAccountToValueMemoThrowableError = ZcashError.rustCreateToAddress("mocked error")
rustBackendMock.proposeShieldingAccountMemoShieldingThresholdTransparentReceiverThrowableError = ZcashError.rustShieldFunds("mocked error")
rustBackendMock.proposeTransferAccountUUIDToValueMemoThrowableError = ZcashError.rustCreateToAddress("mocked error")
rustBackendMock.proposeShieldingAccountUUIDMemoShieldingThresholdTransparentReceiverThrowableError = ZcashError.rustShieldFunds("mocked error")
rustBackendMock.createProposedTransactionsProposalUskThrowableError = ZcashError.rustCreateToAddress("mocked error")
rustBackendMock.decryptAndStoreTransactionTxBytesMinedHeightThrowableError = ZcashError.rustDecryptAndStoreTransaction("mock fail")
@ -145,7 +145,7 @@ extension SynchronizerState {
static var mock: SynchronizerState {
SynchronizerState(
syncSessionID: .nullID,
accountBalance: AccountBalance(saplingBalance: .zero, orchardBalance: .zero, unshielded: Zatoshi(200)),
accountsBalances: [:],
internalSyncStatus: .syncing(0),
latestBlockHeight: 222222
)

2
Tests/TestUtils/TestCoordinator.swift
View File

@ -111,7 +111,7 @@ class TestCoordinator {
}
func prepare(seed: [UInt8]) async throws -> Initializer.InitializationResult {
return try await synchronizer.prepare(with: seed, walletBirthday: self.birthday, for: .newWallet)
return try await synchronizer.prepare(with: seed, walletBirthday: self.birthday, for: .newWallet, name: "", keySource: nil)
}
func stop() async throws {

15
Tests/TestUtils/TestsData.swift
View File

@ -36,7 +36,7 @@ class TestsData {
let transparentAddress = TransparentAddress(validatedEncoding: "t1dRJRY7GmyeykJnMH38mdQoaZtFhn1QmGz")
lazy var pendingTransactionEntity = {
ZcashTransaction.Overview(
accountId: 0,
accountUUID: TestsData.mockedAccountUUID,
blockTime: nil,
expiryHeight: nil,
fee: Zatoshi(10000),
@ -56,7 +56,7 @@ class TestsData {
let clearedTransaction = {
ZcashTransaction.Overview(
accountId: 0,
accountUUID: TestsData.mockedAccountUUID,
blockTime: Date().timeIntervalSince1970,
expiryHeight: 123000,
fee: Zatoshi(10),
@ -76,7 +76,7 @@ class TestsData {
let sentTransaction = {
ZcashTransaction.Overview(
accountId: 0,
accountUUID: TestsData.mockedAccountUUID,
blockTime: 1,
expiryHeight: nil,
fee: Zatoshi(10000),
@ -96,7 +96,7 @@ class TestsData {
let receivedTransaction = {
ZcashTransaction.Overview(
accountId: 0,
accountUUID: TestsData.mockedAccountUUID,
blockTime: 1,
expiryHeight: nil,
fee: nil,
@ -123,3 +123,10 @@ class TestsData {
self.networkType = networkType
}
}
extension TestsData {
/// `mockedAccountUUID` is used in tests only and the main purpose is to make tests buildable.
/// [#1518][#1521] fixes of Offline and Performance tests https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1518, https://github.com/Electric-Coin-Company/zcash-swift-wallet-sdk/issues/1521
/// will eventually address use of this mocked account and ideally remove it completely.
static let mockedAccountUUID = AccountUUID(id: [UInt8](repeating: 0, count: 16))
}