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

Merge pull request #1372 from LukasKorba/1369-SynchronizerState-with-PoolBalance 

[#1369] SynchronizerState refactor
This commit is contained in:
Lukas Korba 2024-02-12 17:41:45 +01:00 committed by GitHub
parent 25e844115d e51f425c54
commit 1faf31a8c9
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
30 changed files with 303 additions and 454 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
CHANGELOG.md
View File

@ -8,6 +8,21 @@ and this library adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
## Changed
### [#1369] SynchronizerState refactor and balances cleanup
`SynchronizerState` cleaned up and changed to provide only `AccountBalance`. This struct holds `saplingBalance: PoolBalance` which represents shielded balance for both total and spendable. Also holds `unshielded: Zatoshi` which represents transparent balance.
## Removed
### [#1369] SynchronizerState refactor and balances cleanup
- `WalletBalance` has been removed from the SDK, replaced with `AccountBalance`.
- `getTransparentBalance(accountIndex: Int)`, use `getAccountBalance(accountIndex: Int = 0)` instead
- `getShieldedBalance(accountIndex: Int)`, use `getAccountBalance(accountIndex: Int = 0)` instead
- `getShieldedVerifiedBalance(accountIndex: Int)`, use `getAccountBalance(accountIndex: Int = 0)` instead
# 2.0.9 - 2024-01-31
## Changed
### [#1363] Account balances in the SynchronizerState
`shieldedBalance: WalletBalance` has been replaced with `accountBalances: AccountBalance`. `AccountBalance` provides the same values as `shieldedBalance` but adds up a pending changes. Under the hood this calls rust's `getWalletSummary` which improved also the syncing initial values of % and balances.
@ -29,7 +44,6 @@ broke shielding.
## Added
- `Model.ScanSummary`
- `Model.WalletSummary.{PoolBalance, AccountBalance, WalletSummary}`
-
## Changed
- The `ZcashError` type has changed.

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

@ -19,8 +19,8 @@ class GetBalanceViewController: UIViewController {
self.title = "Account 0 Balance"
Task { @MainActor in
let balanceText = (try? await synchronizer.getShieldedBalance().formattedString) ?? "0.0"
let verifiedText = (try? await synchronizer.getShieldedVerifiedBalance().formattedString) ?? "0.0"
let balanceText = (try? await synchronizer.getAccountBalance()?.saplingBalance.total().formattedString) ?? "0.0"
let verifiedText = (try? await synchronizer.getAccountBalance()?.saplingBalance.spendableValue.formattedString) ?? "0.0"
self.balance.text = "\(balanceText) ZEC"
self.verified.text = "\(verifiedText) ZEC"
}

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

@ -31,10 +31,10 @@ class GetUTXOsViewController: UIViewController {
self.transparentAddressLabel.text = tAddress
// swiftlint:disable:next force_try
let balance = try! await AppDelegate.shared.sharedSynchronizer.getTransparentBalance(accountIndex: 0)
let balance = try! await AppDelegate.shared.sharedSynchronizer.getAccountBalance(accountIndex: 0)?.unshielded ?? .zero
self.totalBalanceLabel.text = NumberFormatter.zcashNumberFormatter.string(from: NSNumber(value: balance.total.amount))
self.verifiedBalanceLabel.text = NumberFormatter.zcashNumberFormatter.string(from: NSNumber(value: balance.verified.amount))
self.totalBalanceLabel.text = NumberFormatter.zcashNumberFormatter.string(from: NSNumber(value: balance.amount))
self.verifiedBalanceLabel.text = NumberFormatter.zcashNumberFormatter.string(from: NSNumber(value: balance.amount))
}
}

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

@ -103,8 +103,8 @@ class SendViewController: UIViewController {
}
func updateBalance() async {
balanceLabel.text = format(balance: (try? await synchronizer.getShieldedBalance(accountIndex: 0)) ?? .zero)
verifiedBalanceLabel.text = format(balance: (try? await synchronizer.getShieldedVerifiedBalance(accountIndex: 0)) ?? .zero)
balanceLabel.text = format(balance: (try? await synchronizer.getAccountBalance(accountIndex: 0))?.saplingBalance.total() ?? .zero)
verifiedBalanceLabel.text = format(balance: (try? await synchronizer.getAccountBalance(accountIndex: 0))?.saplingBalance.spendableValue ?? .zero)
}
func format(balance: Zatoshi = Zatoshi()) -> String {
@ -118,7 +118,7 @@ class SendViewController: UIViewController {
func maxFundsOn() {
Task { @MainActor in
let fee = Zatoshi(10000)
let max: Zatoshi = ((try? await synchronizer.getShieldedVerifiedBalance(accountIndex: 0)) ?? .zero) - fee
let max: Zatoshi = ((try? await synchronizer.getAccountBalance(accountIndex: 0))?.saplingBalance.spendableValue ?? .zero) - fee
amountTextField.text = format(balance: max)
amountTextField.isEnabled = false
}
@ -140,12 +140,12 @@ class SendViewController: UIViewController {
}
func isBalanceValid() async -> Bool {
let balance = (try? await synchronizer.getShieldedVerifiedBalance(accountIndex: 0)) ?? .zero
let balance = (try? await synchronizer.getAccountBalance(accountIndex: 0))?.saplingBalance.spendableValue ?? .zero
return balance > .zero
}
func isAmountValid() async -> Bool {
let balance = (try? await synchronizer.getShieldedVerifiedBalance(accountIndex: 0)) ?? .zero
let balance = (try? await synchronizer.getAccountBalance(accountIndex: 0))?.saplingBalance.spendableValue ?? .zero
guard
let value = amountTextField.text,
let amount = NumberFormatter.zcashNumberFormatter.number(from: value).flatMap({ Zatoshi($0.int64Value) }),

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

@ -845,21 +845,6 @@ extension CompactBlockProcessor {
func getTransparentAddress(accountIndex: Int) async throws -> TransparentAddress {
try await getUnifiedAddress(accountIndex: accountIndex).transparentReceiver()
}
func getTransparentBalance(accountIndex: Int) async throws -> WalletBalance {
guard accountIndex >= 0 else {
throw ZcashError.compactBlockProcessorInvalidAccount
}
return WalletBalance(
verified: Zatoshi(
try await rustBackend.getVerifiedTransparentBalance(account: Int32(accountIndex))
),
total: Zatoshi(
try await rustBackend.getTransparentBalance(account: Int32(accountIndex))
)
)
}
}
extension CompactBlockProcessor {

8
Sources/ZcashLightClientKit/Block/Download/BlockDownloader.swift
View File

@ -195,23 +195,15 @@ actor BlockDownloaderImpl {
var buffer: [ZcashCompactBlock] = []
logger.debug("Downloading blocks in range: \(range.lowerBound)...\(range.upperBound)")
var startTime = Date()
var lastDownloadedBlockHeight = -1
for _ in stride(from: range.lowerBound, to: range.upperBound + 1, by: 1) {
try Task.checkCancellation()
guard let block = try await stream.nextBlock() else { break }
lastDownloadedBlockHeight = block.height
buffer.append(block)
if buffer.count >= maxBlockBufferSize {
let finishTime = Date()
try await storage.write(blocks: buffer)
try await blocksBufferWritten(buffer)
buffer.removeAll(keepingCapacity: true)
startTime = finishTime
}
}

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

@ -62,7 +62,6 @@ extension UTXOFetcherImpl: UTXOFetcher {
var refreshed: [UnspentTransactionOutputEntity] = []
var skipped: [UnspentTransactionOutputEntity] = []
let startTime = Date()
let all = Float(utxos.count)
var counter = Float(0)
for utxo in utxos {

8
Sources/ZcashLightClientKit/ClosureSynchronizer.swift
View File

@ -68,12 +68,8 @@ public protocol ClosureSynchronizer {
func refreshUTXOs(address: TransparentAddress, from height: BlockHeight, completion: @escaping (Result<RefreshedUTXOs, Error>) -> Void)
func getTransparentBalance(accountIndex: Int, completion: @escaping (Result<WalletBalance, Error>) -> Void)
func getShieldedBalance(accountIndex: Int, completion: @escaping (Result<Zatoshi, Error>) -> Void)
func getShieldedVerifiedBalance(accountIndex: Int, completion: @escaping (Result<Zatoshi, Error>) -> Void)
func getAccountBalance(accountIndex: Int, completion: @escaping (Result<AccountBalance?, Error>) -> Void)
/*
It can be missleading that these two methods are returning Publisher even this protocol is closure based. Reason is that Synchronizer doesn't
provide different implementations for these two methods. So Combine it is even here.

4
Sources/ZcashLightClientKit/CombineSynchronizer.swift
View File

@ -64,9 +64,7 @@ public protocol CombineSynchronizer {
func refreshUTXOs(address: TransparentAddress, from height: BlockHeight) -> SinglePublisher<RefreshedUTXOs, Error>
func getTransparentBalance(accountIndex: Int) -> SinglePublisher<WalletBalance, Error>
func getShieldedBalance(accountIndex: Int) -> SinglePublisher<Zatoshi, Error>
func getShieldedVerifiedBalance(accountIndex: Int) -> SinglePublisher<Zatoshi, Error>
func getAccountBalance(accountIndex: Int) -> SinglePublisher<AccountBalance?, Error>
func rewind(_ policy: RewindPolicy) -> CompletablePublisher<Error>
func wipe() -> CompletablePublisher<Error>

27
Sources/ZcashLightClientKit/DAO/UnspentTransactionOutputDao.swift
View File

@ -183,33 +183,6 @@ class UnspentTransactionOutputSQLDAO: UnspentTransactionOutputRepository {
}
}
}
/// - Throws: `unspentTransactionOutputDAOBalance` if sqlite query fails.
func balance(address: String, latestHeight: BlockHeight) async throws -> WalletBalance {
do {
let verified = try dbProvider.connection().scalarLocked(
table.select(TableColumns.valueZat.sum)
.filter(TableColumns.address == address)
.filter(TableColumns.height <= latestHeight - ZcashSDK.defaultStaleTolerance)
) ?? 0
let total = try dbProvider.connection().scalarLocked(
table.select(TableColumns.valueZat.sum)
.filter(TableColumns.address == address)
) ?? 0
return WalletBalance(
verified: Zatoshi(Int64(verified)),
total: Zatoshi(Int64(total))
)
} catch {
throw ZcashError.unspentTransactionOutputDAOBalance(error)
}
}
}
struct TransparentBalance {
var balance: WalletBalance
var address: String
}
enum UTXORepositoryBuilder {

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

@ -584,9 +584,6 @@ public enum ZcashError: Equatable, Error {
/// Indicates that this Synchronizer is disconnected from its lightwalletd server.
/// ZSYNCO0006
case synchronizerDisconnected
/// The attempt to switch endpoints failed. Check that the hostname and port are correct, and are formatted as <hostname>:<port>.
/// ZSYNCO0007
case synchronizerServerSwitch
public var message: String {
switch self {
@ -757,7 +754,6 @@ public enum ZcashError: Equatable, Error {
case .synchronizerLatestUTXOsInvalidTAddress: return "LatestUTXOs for the address failed, invalid t-address."
case .synchronizerRewindUnknownArchorHeight: return "Rewind failed, unknown archor height"
case .synchronizerDisconnected: return "Indicates that this Synchronizer is disconnected from its lightwalletd server."
case .synchronizerServerSwitch: return "The attempt to switch endpoints failed. Check that the hostname and port are correct, and are formatted as <hostname>:<port>."
}
}
@ -930,7 +926,6 @@ public enum ZcashError: Equatable, Error {
case .synchronizerLatestUTXOsInvalidTAddress: return .synchronizerLatestUTXOsInvalidTAddress
case .synchronizerRewindUnknownArchorHeight: return .synchronizerRewindUnknownArchorHeight
case .synchronizerDisconnected: return .synchronizerDisconnected
case .synchronizerServerSwitch: return .synchronizerServerSwitch
}
}

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

@ -343,6 +343,4 @@ public enum ZcashErrorCode: String {
case synchronizerRewindUnknownArchorHeight = "ZSYNCO0005"
/// Indicates that this Synchronizer is disconnected from its lightwalletd server.
case synchronizerDisconnected = "ZSYNCO0006"
/// The attempt to switch endpoints failed. Check that the hostname and port are correct, and are formatted as <hostname>:<port>.
case synchronizerServerSwitch = "ZSYNCO0007"
}

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

@ -348,7 +348,7 @@ enum ZcashErrorDefinition {
/// - `rustError` contains error generated by the rust layer.
// sourcery: code="ZRUST0056"
case rustGetWalletSummary(_ rustError: String)
// MARK: - Account DAO
/// SQLite query failed when fetching all accounts from the database.
@ -666,4 +666,7 @@ enum ZcashErrorDefinition {
/// The attempt to switch endpoints failed. Check that the hostname and port are correct, and are formatted as <hostname>:<port>.
// sourcery: code="ZSYNCO0007"
case synchronizerServerSwitch
/// The spending key does not belong to the wallet.
// sourcery: code="ZSYNCO0008"
case synchronizerSpendingKeyDoesNotBelongToTheWallet
}

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

@ -263,19 +263,3 @@ public enum Recipient: Equatable, StringEncoded {
}
}
}
public struct WalletBalance: Equatable {
public let verified: Zatoshi
public let total: Zatoshi
public init(verified: Zatoshi, total: Zatoshi) {
self.verified = verified
self.total = total
}
}
public extension WalletBalance {
static var zero: WalletBalance {
Self(verified: .zero, total: .zero)
}
}

1
Sources/ZcashLightClientKit/Repository/UnspentTransactionOutputRepository.swift
View File

@ -10,7 +10,6 @@ import Foundation
protocol UnspentTransactionOutputRepository {
func initialise() async throws
func getAll(address: String?) async throws -> [UnspentTransactionOutputEntity]
func balance(address: String, latestHeight: BlockHeight) async throws -> WalletBalance
func store(utxos: [UnspentTransactionOutputEntity]) async throws
func clearAll(address: String?) async throws
}

34
Sources/ZcashLightClientKit/Synchronizer.swift
View File

@ -35,10 +35,8 @@ public struct SynchronizerState: Equatable {
/// given how application lifecycle varies between OS Versions, platforms, etc.
/// SyncSessionIDs are provided to users
public var syncSessionID: UUID
/// account (shielded) balances known to this synchronizer given the data that has processed locally
public var accountBalances: AccountBalance
/// transparent balance known to this synchronizer given the data that has processed locally
public var transparentBalance: WalletBalance
/// account balance known to this synchronizer given the data that has processed locally
public var accountBalance: AccountBalance?
/// status of the whole sync process
var internalSyncStatus: InternalSyncStatus
public var syncStatus: SyncStatus
@ -49,8 +47,7 @@ public struct SynchronizerState: Equatable {
public static var zero: SynchronizerState {
SynchronizerState(
syncSessionID: .nullID,
accountBalances: .zero,
transparentBalance: .zero,
accountBalance: .zero,
internalSyncStatus: .unprepared,
latestBlockHeight: .zero
)
@ -58,14 +55,12 @@ public struct SynchronizerState: Equatable {
init(
syncSessionID: UUID,
accountBalances: AccountBalance,
transparentBalance: WalletBalance,
accountBalance: AccountBalance?,
internalSyncStatus: InternalSyncStatus,
latestBlockHeight: BlockHeight
) {
self.syncSessionID = syncSessionID
self.accountBalances = accountBalances
self.transparentBalance = transparentBalance
self.accountBalance = accountBalance
self.internalSyncStatus = internalSyncStatus
self.latestBlockHeight = latestBlockHeight
self.syncStatus = internalSyncStatus.mapToSyncStatus()
@ -236,23 +231,10 @@ public protocol Synchronizer: AnyObject {
/// `SynchronizerErrors.notPrepared`.
func refreshUTXOs(address: TransparentAddress, from height: BlockHeight) async throws -> RefreshedUTXOs
/// Returns the last stored transparent balance
func getTransparentBalance(accountIndex: Int) async throws -> WalletBalance
/// get (unverified) balance from the given account index
/// Account balances from the given account index
/// - Parameter accountIndex: the index of the account
/// - Returns: balance in `Zatoshi`
func getShieldedBalance(accountIndex: Int) async throws -> Zatoshi
/// get verified balance from the given account index
/// - Parameter accountIndex: the index of the account
/// - Returns: balance in `Zatoshi`
func getShieldedVerifiedBalance(accountIndex: Int) async throws -> Zatoshi
/// get account balances from the given account index
/// - Parameter accountIndex: the index of the account
/// - Returns: balances
func getAccountBalances(accountIndex: Int) async throws -> AccountBalance?
/// - Returns: `AccountBalance`, struct that holds sapling and unshielded balances or `nil` when no account is associated with `accountIndex`
func getAccountBalance(accountIndex: Int) async throws -> AccountBalance?
/// Rescans the known blocks with the current keys.
///

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

@ -147,21 +147,9 @@ extension ClosureSDKSynchronizer: ClosureSynchronizer {
}
}
public func getTransparentBalance(accountIndex: Int, completion: @escaping (Result<WalletBalance, Error>) -> Void) {
public func getAccountBalance(accountIndex: Int, completion: @escaping (Result<AccountBalance?, Error>) -> Void) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.getTransparentBalance(accountIndex: accountIndex)
}
}
public func getShieldedBalance(accountIndex: Int, completion: @escaping (Result<Zatoshi, Error>) -> Void) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.getShieldedBalance(accountIndex: accountIndex)
}
}
public func getShieldedVerifiedBalance(accountIndex: Int, completion: @escaping (Result<Zatoshi, Error>) -> Void) {
AsyncToClosureGateway.executeThrowingAction(completion) {
try await self.synchronizer.getShieldedVerifiedBalance(accountIndex: accountIndex)
try await self.synchronizer.getAccountBalance(accountIndex: accountIndex)
}
}

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

@ -140,21 +140,9 @@ extension CombineSDKSynchronizer: CombineSynchronizer {
}
}
public func getTransparentBalance(accountIndex: Int) -> SinglePublisher<WalletBalance, Error> {
public func getAccountBalance(accountIndex: Int) -> SinglePublisher<AccountBalance?, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await self.synchronizer.getTransparentBalance(accountIndex: accountIndex)
}
}
public func getShieldedBalance(accountIndex: Int = 0) -> SinglePublisher<Zatoshi, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await synchronizer.getShieldedBalance(accountIndex: accountIndex)
}
}
public func getShieldedVerifiedBalance(accountIndex: Int = 0) -> SinglePublisher<Zatoshi, Error> {
AsyncToCombineGateway.executeThrowingAction() {
try await synchronizer.getShieldedVerifiedBalance(accountIndex: accountIndex)
try await self.synchronizer.getAccountBalance(accountIndex: accountIndex)
}
}

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

@ -302,10 +302,13 @@ public class SDKSynchronizer: Synchronizer {
// let's see if there are funds to shield
let accountIndex = Int(spendingKey.account)
let tBalance = try await self.getTransparentBalance(accountIndex: accountIndex)
guard let tBalance = try await self.getAccountBalance(accountIndex: 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.verified >= self.network.constants.defaultFee() else {
guard tBalance >= self.network.constants.defaultFee() else {
throw ZcashError.synchronizerShieldFundsInsuficientTransparentFunds
}
@ -414,20 +417,10 @@ public class SDKSynchronizer: Synchronizer {
return try await blockProcessor.refreshUTXOs(tAddress: address, startHeight: height)
}
public func getAccountBalances(accountIndex: Int = 0) async throws -> AccountBalance? {
public func getAccountBalance(accountIndex: Int = 0) async throws -> AccountBalance? {
try await initializer.rustBackend.getWalletSummary()?.accountBalances[UInt32(accountIndex)]
}
public func getShieldedBalance(accountIndex: Int = 0) async throws -> Zatoshi {
try await initializer.rustBackend.getWalletSummary()?.accountBalances[UInt32(accountIndex)]?
.saplingBalance.total() ?? Zatoshi.zero
}
public func getShieldedVerifiedBalance(accountIndex: Int = 0) async throws -> Zatoshi {
try await initializer.rustBackend.getWalletSummary()?.accountBalances[UInt32(accountIndex)]?
.saplingBalance.spendableValue ?? Zatoshi.zero
}
public func getUnifiedAddress(accountIndex: Int) async throws -> UnifiedAddress {
try await blockProcessor.getUnifiedAddress(accountIndex: accountIndex)
}
@ -440,11 +433,6 @@ public class SDKSynchronizer: Synchronizer {
try await blockProcessor.getTransparentAddress(accountIndex: accountIndex)
}
/// Returns the last stored transparent balance
public func getTransparentBalance(accountIndex: Int) async throws -> WalletBalance {
try await blockProcessor.getTransparentBalance(accountIndex: accountIndex)
}
// MARK: Rewind
public func rewind(_ policy: RewindPolicy) -> AnyPublisher<Void, Error> {
@ -621,8 +609,7 @@ public class SDKSynchronizer: Synchronizer {
private func snapshotState(status: InternalSyncStatus) async -> SynchronizerState {
await SynchronizerState(
syncSessionID: syncSession.value,
accountBalances: (try? await getAccountBalances()) ?? .zero,
transparentBalance: (try? await blockProcessor.getTransparentBalance(accountIndex: 0)) ?? .zero,
accountBalance: try? await getAccountBalance(),
internalSyncStatus: status,
latestBlockHeight: latestBlocksDataProvider.latestBlockHeight
)

85
Tests/DarksideTests/AdvancedReOrgTests.swift
View File

@ -100,8 +100,8 @@ class AdvancedReOrgTests: ZcashTestCase {
try await coordinator.sync(
completion: { synchro in
synchronizer = synchro
initialVerifiedBalance = try await synchro.getShieldedVerifiedBalance()
initialTotalBalance = try await synchro.getShieldedBalance()
initialVerifiedBalance = try await synchro.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
initialTotalBalance = try await synchro.getAccountBalance()?.saplingBalance.total() ?? .zero
preTxExpectation.fulfill()
shouldContinue = true
},
@ -135,8 +135,8 @@ class AdvancedReOrgTests: ZcashTestCase {
try await coordinator.sync(
completion: { synchro in
synchronizer = synchro
receivedTxVerifiedBalance = try await synchro.getShieldedVerifiedBalance()
receivedTxTotalBalance = try await synchro.getShieldedBalance()
receivedTxVerifiedBalance = try await synchro.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
receivedTxTotalBalance = try await synchro.getAccountBalance()?.saplingBalance.total() ?? .zero
receivedTxExpectation.fulfill()
}, error: self.handleError
)
@ -202,8 +202,8 @@ class AdvancedReOrgTests: ZcashTestCase {
do {
try await coordinator.sync(
completion: { synchronizer in
afterReorgTxTotalBalance = try await synchronizer.getShieldedBalance()
afterReorgTxVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
afterReorgTxTotalBalance = try await synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
afterReorgTxVerifiedBalance = try await synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
reorgSyncexpectation.fulfill()
},
error: self.handleError
@ -238,8 +238,8 @@ class AdvancedReOrgTests: ZcashTestCase {
do {
try await coordinator.sync(
completion: { synchronizer in
finalReorgTxTotalBalance = try await synchronizer.getShieldedBalance()
finalReorgTxVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
finalReorgTxTotalBalance = try await synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
finalReorgTxVerifiedBalance = try await synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
finalsyncExpectation.fulfill()
},
error: self.handleError
@ -304,7 +304,7 @@ class AdvancedReOrgTests: ZcashTestCase {
do {
try await coordinator.sync(
completion: { synchronizer in
initialTotalBalance = try await synchronizer.getShieldedBalance()
initialTotalBalance = try await synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
preTxExpectation.fulfill()
},
error: self.handleError
@ -450,13 +450,13 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [lastSyncExpectation], timeout: 5)
let expectedVerifiedBalance = initialTotalBalance + pendingTx.value
let currentVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let currentVerifiedBalance = try await coordinator.synchronizer.getAccountBalance()?.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.getShieldedBalance()
let resultingBalance: Zatoshi = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
XCTAssertEqual(resultingBalance, currentVerifiedBalance)
}
@ -480,8 +480,8 @@ class AdvancedReOrgTests: ZcashTestCase {
var preReorgVerifiedBalance = Zatoshi.zero
try await coordinator.sync(
completion: { synchronizer in
preReorgTotalBalance = try await synchronizer.getShieldedBalance()
preReorgVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
preReorgTotalBalance = try await synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
preReorgVerifiedBalance = try await synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
firstSyncExpectation.fulfill()
},
error: self.handleError
@ -503,8 +503,8 @@ class AdvancedReOrgTests: ZcashTestCase {
var postReorgVerifiedBalance = Zatoshi.zero
try await coordinator.sync(
completion: { synchronizer in
postReorgTotalBalance = try await synchronizer.getShieldedBalance()
postReorgVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
postReorgTotalBalance = try await synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
postReorgVerifiedBalance = try await synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
afterReorgSync.fulfill()
},
error: self.handleError
@ -527,8 +527,8 @@ class AdvancedReOrgTests: ZcashTestCase {
try await coordinator.sync(
completion: { synchronizer in
initialBalance = try await synchronizer.getShieldedBalance()
initialVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
initialBalance = try await synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
initialVerifiedBalance = try await synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
expectation.fulfill()
},
error: self.handleError
@ -546,8 +546,8 @@ class AdvancedReOrgTests: ZcashTestCase {
try await coordinator.sync(
completion: { synchronizer in
afterTxBalance = try await synchronizer.getShieldedBalance()
afterTxVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
afterTxBalance = try await synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
afterTxVerifiedBalance = try await synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
let receivedTransactions = await synchronizer.receivedTransactions
XCTAssertNotNil(
receivedTransactions.first { $0.minedHeight == receivedTxHeight },
@ -576,8 +576,8 @@ class AdvancedReOrgTests: ZcashTestCase {
try await coordinator.sync(
completion: { synchronizer in
afterReOrgBalance = try await synchronizer.getShieldedBalance()
afterReOrgVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
afterReOrgBalance = try await synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
afterReOrgVerifiedBalance = try await synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
let receivedTransactions = await synchronizer.receivedTransactions
XCTAssertNil(
receivedTransactions.first { $0.minedHeight == receivedTxHeight },
@ -653,8 +653,9 @@ class AdvancedReOrgTests: ZcashTestCase {
/*
1a. save balances
*/
initialBalance = try await coordinator.synchronizer.getShieldedBalance()
initialVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
var accountBalance = try await coordinator.synchronizer.getAccountBalance()
initialBalance = accountBalance?.saplingBalance.total() ?? .zero
initialVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
incomingTx = await coordinator.synchronizer.receivedTransactions.first(where: { $0.minedHeight == incomingTxHeight })
let txRawData = incomingTx.raw ?? Data()
@ -701,8 +702,9 @@ class AdvancedReOrgTests: ZcashTestCase {
/*
7. check that balances still match
*/
let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedVerifiedBalance, initialVerifiedBalance)
XCTAssertEqual(expectedBalance, initialBalance)
}
@ -721,8 +723,8 @@ class AdvancedReOrgTests: ZcashTestCase {
try await coordinator.sync(
completion: { synchronizer in
initialBalance = try await synchronizer.getShieldedBalance()
initialVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
initialBalance = try await synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
initialVerifiedBalance = try await synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
firstSyncExpectation.fulfill()
},
error: self.handleError
@ -746,8 +748,9 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [lastSyncExpectation], timeout: 5)
let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
let accountBalance = try await coordinator.synchronizer.getAccountBalance()
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, initialBalance)
XCTAssertEqual(expectedVerifiedBalance, initialVerifiedBalance)
}
@ -1078,8 +1081,9 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 5)
let initialBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
let initialVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
var accountBalance = try await coordinator.synchronizer.getAccountBalance()
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 {
XCTFail("no incoming transaction found!")
return
@ -1108,8 +1112,9 @@ class AdvancedReOrgTests: ZcashTestCase {
return
}
let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(initialVerifiedBalance, expectedVerifiedBalance)
XCTAssertEqual(initialBalance, expectedBalance)
XCTAssert(afterReOrgTxHeight > initialTxHeight)
@ -1158,8 +1163,9 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 5)
let initialTotalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
let initialVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
var accountBalance = try await coordinator.synchronizer.getAccountBalance()
let initialTotalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
let initialVerifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
try coordinator.applyStaged(blockheight: reorgHeight - 1)
sleep(1)
@ -1196,8 +1202,9 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [afterReorgSyncExpectation], timeout: 5)
let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(initialVerifiedBalance, expectedVerifiedBalance)
XCTAssertEqual(initialTotalBalance, expectedBalance)
}
@ -1246,7 +1253,7 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 10)
sleep(1)
let initialTotalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
let initialTotalBalance: Zatoshi = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
let sendExpectation = XCTestExpectation(description: "send expectation")
var pendingEntity: ZcashTransaction.Overview?
@ -1366,7 +1373,7 @@ class AdvancedReOrgTests: ZcashTestCase {
await fulfillment(of: [lastSyncExpectation], timeout: 5)
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
let expectedBalance = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, initialTotalBalance)
}

83
Tests/DarksideTests/BalanceTests.swift
View File

@ -84,8 +84,9 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 12)
// 2 check that there are no unconfirmed funds
let verifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let totalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
var accountBalance = try await coordinator.synchronizer.getAccountBalance()
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
XCTAssertEqual(verifiedBalance, totalBalance)
@ -198,8 +199,9 @@ class BalanceTests: ZcashTestCase {
//
// XCTAssertNil(confirmedPending, "pending, now confirmed transaction found")
let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, .zero)
XCTAssertEqual(expectedVerifiedBalance, .zero)
}
@ -236,8 +238,9 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 12)
// 2 check that there are no unconfirmed funds
let verifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let totalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
var accountBalance = try await coordinator.synchronizer.getAccountBalance()
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
XCTAssertEqual(verifiedBalance, totalBalance)
@ -351,8 +354,9 @@ class BalanceTests: ZcashTestCase {
//
// XCTAssertNil(confirmedPending, "pending, now confirmed transaction found")
let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, .zero)
XCTAssertEqual(expectedVerifiedBalance, .zero)
}
@ -383,8 +387,9 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 12)
// 2 check that there are no unconfirmed funds
let verifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let totalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
let accountBalance = try await coordinator.synchronizer.getAccountBalance()
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
XCTAssertEqual(verifiedBalance, totalBalance)
@ -448,8 +453,9 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 12)
// 2 check that there are no unconfirmed funds
let verifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let totalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
var accountBalance = try await coordinator.synchronizer.getAccountBalance()
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
XCTAssertEqual(verifiedBalance, totalBalance)
@ -563,8 +569,9 @@ class BalanceTests: ZcashTestCase {
//
// XCTAssertNil(confirmedPending, "pending, now confirmed transaction found")
let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, Zatoshi(100000))
XCTAssertEqual(expectedVerifiedBalance, Zatoshi(100000))
}
@ -608,7 +615,7 @@ class BalanceTests: ZcashTestCase {
let spendingKey = coordinator.spendingKey
let presendVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let presendVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
/*
there's more zatoshi to send than network fee
@ -626,7 +633,7 @@ class BalanceTests: ZcashTestCase {
pendingTx = transaction
self.sentTransactionExpectation.fulfill()
var expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
var expectedVerifiedBalance = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
XCTAssertTrue(expectedVerifiedBalance > .zero)
await fulfillment(of: [sentTransactionExpectation], timeout: 12)
@ -659,8 +666,9 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [mineExpectation], timeout: 5)
expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
let accountBalance = try await coordinator.synchronizer.getAccountBalance()
expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(
presendVerifiedBalance - self.sendAmount - network.constants.defaultFee(),
@ -709,7 +717,7 @@ class BalanceTests: ZcashTestCase {
spentValue: sentOutput.value,
fee: fee,
sentAmount: self.sendAmount,
currentVerifiedBalance: try await coordinator.synchronizer.getShieldedVerifiedBalance()
currentVerifiedBalance: try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
)
}
@ -751,7 +759,7 @@ class BalanceTests: ZcashTestCase {
let spendingKey = coordinator.spendingKey
let presendBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
let presendBalance: Zatoshi = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
// there's more zatoshi to send than network fee
XCTAssertTrue(presendBalance >= network.constants.defaultFee() + sendAmount)
@ -773,11 +781,12 @@ class BalanceTests: ZcashTestCase {
XCTFail("sendToAddress failed: \(error)")
}
var expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let accountBalance = try await coordinator.synchronizer.getAccountBalance()
var expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
XCTAssertTrue(expectedVerifiedBalance > .zero)
await fulfillment(of: [sentTransactionExpectation], timeout: 12)
expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
if let testError {
XCTAssertEqual(expectedVerifiedBalance, presendBalance)
XCTFail("error: \(testError)")
@ -790,7 +799,7 @@ class BalanceTests: ZcashTestCase {
XCTAssertEqual(transaction.value, self.sendAmount)
var expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
var expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(
expectedBalance,
presendBalance - self.sendAmount - network.constants.defaultFee()
@ -822,7 +831,7 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [mineExpectation], timeout: 5)
expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
expectedBalance = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
XCTAssertEqual(
presendBalance - self.sendAmount - network.constants.defaultFee(),
expectedBalance
@ -859,7 +868,7 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [syncedExpectation], timeout: 5)
let clearedTransactions = await coordinator.synchronizer.transactions
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
let expectedBalance = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
XCTAssertEqual(clearedTransactions.count, 2)
XCTAssertEqual(expectedBalance, Zatoshi(200000))
}
@ -911,8 +920,9 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [syncedExpectation], timeout: 6)
let previousVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let previousTotalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
let accountBalance = try await coordinator.synchronizer.getAccountBalance()
let previousVerifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let previousTotalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
let spendingKey = coordinator.spendingKey
@ -1019,11 +1029,11 @@ class BalanceTests: ZcashTestCase {
spentValue: sentOutput.value,
fee: fee,
sentAmount: self.sendAmount,
currentVerifiedBalance: try await synchronizer.getShieldedVerifiedBalance()
currentVerifiedBalance: try await synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
)
self.totalBalanceValidation(
totalBalance: try await synchronizer.getShieldedBalance(),
totalBalance: try await synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero,
previousTotalbalance: previousTotalBalance,
sentAmount: self.sendAmount
)
@ -1082,8 +1092,9 @@ class BalanceTests: ZcashTestCase {
let spendingKey = coordinator.spendingKey
let previousVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let previousTotalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
var accountBalance = try await coordinator.synchronizer.getAccountBalance()
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 {
@ -1097,8 +1108,9 @@ class BalanceTests: ZcashTestCase {
sendExpectation.fulfill()
} catch {
// balance should be the same as before sending if transaction failed
let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
let accountBalance = try await coordinator.synchronizer.getAccountBalance()
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedVerifiedBalance, previousVerifiedBalance)
XCTAssertEqual(expectedBalance, previousTotalBalance)
XCTFail("sendToAddress failed: \(error)")
@ -1130,8 +1142,9 @@ class BalanceTests: ZcashTestCase {
await fulfillment(of: [expirationSyncExpectation], timeout: 5)
let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
/*
Verified Balance is equal to verified balance previously shown before sending the expired transaction
*/

54
Tests/DarksideTests/RewindRescanTests.swift
View File

@ -70,8 +70,9 @@ class RewindRescanTests: ZcashTestCase {
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
try coordinator.applyStaged(blockheight: defaultLatestHeight + 50)
let initialVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let initialTotalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
var accountBalance = try await coordinator.synchronizer.getAccountBalance()
let initialVerifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let initialTotalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
sleep(1)
let firstSyncExpectation = XCTestExpectation(description: "first sync expectation")
@ -87,8 +88,9 @@ class RewindRescanTests: ZcashTestCase {
}
await fulfillment(of: [firstSyncExpectation], timeout: 12)
let verifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let totalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
// 2 check that there are no unconfirmed funds
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
XCTAssertEqual(verifiedBalance, totalBalance)
@ -123,8 +125,9 @@ class RewindRescanTests: ZcashTestCase {
// XCTAssertEqual(lastScannedHeight, self.birthday)
// check that the balance is cleared
var expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
var expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
var expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
var expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(initialVerifiedBalance, expectedVerifiedBalance)
XCTAssertEqual(initialTotalBalance, expectedBalance)
let secondScanExpectation = XCTestExpectation(description: "rescan")
@ -143,8 +146,9 @@ class RewindRescanTests: ZcashTestCase {
await fulfillment(of: [secondScanExpectation], timeout: 12)
// verify that the balance still adds up
expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(verifiedBalance, expectedVerifiedBalance)
XCTAssertEqual(totalBalance, expectedBalance)
}
@ -161,7 +165,7 @@ class RewindRescanTests: ZcashTestCase {
let newChaintTip = defaultLatestHeight + 10000
try coordinator.applyStaged(blockheight: newChaintTip)
sleep(3)
let initialVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let initialVerifiedBalance: Zatoshi = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
let firstSyncExpectation = XCTestExpectation(description: "first sync expectation")
do {
@ -176,8 +180,9 @@ class RewindRescanTests: ZcashTestCase {
}
await fulfillment(of: [firstSyncExpectation], timeout: 20)
let verifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let totalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
var accountBalance = try await coordinator.synchronizer.getAccountBalance()
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
// 2 check that there are no unconfirmed funds
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
XCTAssertEqual(verifiedBalance, totalBalance)
@ -216,7 +221,7 @@ class RewindRescanTests: ZcashTestCase {
await fulfillment(of: [rewindExpectation], timeout: 2)
// check that the balance is cleared
var expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
var expectedVerifiedBalance = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.spendableValue ?? .zero
XCTAssertEqual(initialVerifiedBalance, expectedVerifiedBalance)
let secondScanExpectation = XCTestExpectation(description: "rescan")
@ -235,8 +240,9 @@ class RewindRescanTests: ZcashTestCase {
await fulfillment(of: [secondScanExpectation], timeout: 20)
// verify that the balance still adds up
expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(verifiedBalance, expectedVerifiedBalance)
XCTAssertEqual(totalBalance, expectedBalance)
@ -274,8 +280,9 @@ class RewindRescanTests: ZcashTestCase {
)
await fulfillment(of: [firstSyncExpectation], timeout: 12)
let verifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let totalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
var accountBalance = try await coordinator.synchronizer.getAccountBalance()
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
// 2 check that there are no unconfirmed funds
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
XCTAssertEqual(verifiedBalance, totalBalance)
@ -327,8 +334,9 @@ class RewindRescanTests: ZcashTestCase {
await fulfillment(of: [secondScanExpectation], timeout: 12)
// verify that the balance still adds up
let expectedVerifiedBalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
let expectedVerifiedBalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(verifiedBalance, expectedVerifiedBalance)
XCTAssertEqual(totalBalance, expectedBalance)
}
@ -363,8 +371,9 @@ class RewindRescanTests: ZcashTestCase {
await fulfillment(of: [firstSyncExpectation], timeout: 12)
// 2 check that there are no unconfirmed funds
let verifiedBalance: Zatoshi = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let totalBalance: Zatoshi = try await coordinator.synchronizer.getShieldedBalance()
var accountBalance = try await coordinator.synchronizer.getAccountBalance()
let verifiedBalance: Zatoshi = accountBalance?.saplingBalance.spendableValue ?? .zero
let totalBalance: Zatoshi = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertTrue(verifiedBalance > network.constants.defaultFee())
XCTAssertEqual(verifiedBalance, totalBalance)
@ -518,8 +527,9 @@ class RewindRescanTests: ZcashTestCase {
//
// XCTAssertNil(confirmedPending, "pending, now confirmed transaction found")
let expectedVerifiedbalance = try await coordinator.synchronizer.getShieldedVerifiedBalance()
let expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
accountBalance = try await coordinator.synchronizer.getAccountBalance()
let expectedVerifiedbalance = accountBalance?.saplingBalance.spendableValue ?? .zero
let expectedBalance = accountBalance?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, .zero)
XCTAssertEqual(expectedVerifiedbalance, .zero)
}

44
Tests/DarksideTests/ShieldFundsTests.swift
View File

@ -99,7 +99,7 @@ class ShieldFundsTests: ZcashTestCase {
var initialTotalBalance = Zatoshi(-1)
var initialVerifiedBalance = Zatoshi(-1)
var initialTransparentBalance: WalletBalance = try await coordinator.synchronizer.getTransparentBalance(accountIndex: 0)
var initialTransparentBalance: Zatoshi = try await coordinator.synchronizer.getAccountBalance(accountIndex: 0)?.unshielded ?? .zero
let utxo = try GetAddressUtxosReply(jsonString:
"""
@ -121,8 +121,8 @@ class ShieldFundsTests: ZcashTestCase {
do {
try await coordinator.sync(
completion: { synchronizer in
initialVerifiedBalance = try await synchronizer.getShieldedVerifiedBalance()
initialTotalBalance = try await synchronizer.getShieldedBalance()
initialVerifiedBalance = try await synchronizer.getAccountBalance(accountIndex: 0)?.saplingBalance.spendableValue ?? .zero
initialTotalBalance = try await synchronizer.getAccountBalance(accountIndex: 0)?.saplingBalance.total() ?? .zero
preTxExpectation.fulfill()
shouldContinue = true
},
@ -142,10 +142,9 @@ 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.getTransparentBalance(accountIndex: 0)) ?? .zero
initialTransparentBalance = (try? await coordinator.synchronizer.getAccountBalance(accountIndex: 0))?.unshielded ?? .zero
XCTAssertEqual(initialTransparentBalance.total, .zero)
XCTAssertEqual(initialTransparentBalance.verified, .zero)
XCTAssertEqual(initialTransparentBalance, .zero)
// 4. Add the UTXO to darksidewalletd fake chain
try coordinator.service.addUTXO(utxo)
@ -176,10 +175,9 @@ 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.getTransparentBalance(accountIndex: 0)
let tFundsDetectedBalance = try await coordinator.synchronizer.getAccountBalance(accountIndex: 0)?.unshielded ?? .zero
XCTAssertEqual(tFundsDetectedBalance.total, Zatoshi(10000))
XCTAssertEqual(tFundsDetectedBalance.verified, .zero)
XCTAssertEqual(tFundsDetectedBalance, Zatoshi(10000))
let tFundsConfirmationSyncExpectation = XCTestExpectation(description: "t funds confirmation")
@ -206,10 +204,9 @@ 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.getTransparentBalance(accountIndex: 0)
let confirmedTFundsBalance = try await coordinator.synchronizer.getAccountBalance(accountIndex: 0)?.unshielded ?? .zero
XCTAssertEqual(confirmedTFundsBalance.total, Zatoshi(10000))
XCTAssertEqual(confirmedTFundsBalance.verified, Zatoshi(10000))
XCTAssertEqual(confirmedTFundsBalance, Zatoshi(10000))
// 9. shield the funds
let shieldFundsExpectation = XCTestExpectation(description: "shield funds")
@ -238,15 +235,13 @@ class ShieldFundsTests: ZcashTestCase {
guard shouldContinue else { return }
let postShieldingBalance = try await coordinator.synchronizer.getTransparentBalance(accountIndex: 0)
let postShieldingBalance = try await coordinator.synchronizer.getAccountBalance(accountIndex: 0)?.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.verified, Zatoshi(10000))
// FIXME: [#720] this should be zero, https://github.com/zcash/ZcashLightClientKit/issues/720
XCTAssertEqual(postShieldingBalance.total, Zatoshi(10000))
var expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
XCTAssertEqual(postShieldingBalance, Zatoshi(10000))
var expectedBalance = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, .zero)
// 10. clear the UTXO from darksidewalletd's cache
@ -293,13 +288,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.getTransparentBalance(accountIndex: 0)
let postShieldingShieldedBalance = try await coordinator.synchronizer.getAccountBalance(accountIndex: 0)?.unshielded ?? .zero
XCTAssertEqual(postShieldingShieldedBalance.total, .zero)
XCTAssertEqual(postShieldingShieldedBalance.verified, .zero)
XCTAssertEqual(postShieldingShieldedBalance, .zero)
expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
expectedBalance = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, Zatoshi(9000))
// 14. proceed confirm the shielded funds by staging ten more blocks
@ -335,11 +328,10 @@ class ShieldFundsTests: ZcashTestCase {
XCTAssertNotNil(clearedTransaction)
expectedBalance = try await coordinator.synchronizer.getShieldedBalance()
expectedBalance = try await coordinator.synchronizer.getAccountBalance()?.saplingBalance.total() ?? .zero
XCTAssertEqual(expectedBalance, Zatoshi(9000))
let postShieldingConfirmationShieldedBalance = try await coordinator.synchronizer.getTransparentBalance(accountIndex: 0)
XCTAssertEqual(postShieldingConfirmationShieldedBalance.total, .zero)
XCTAssertEqual(postShieldingConfirmationShieldedBalance.verified, .zero)
let postShieldingConfirmationShieldedBalance = try await coordinator.synchronizer.getAccountBalance(accountIndex: 0)?.unshielded ?? .zero
XCTAssertEqual(postShieldingConfirmationShieldedBalance, .zero)
}
func handleError(_ error: Error?) async {

42
Tests/DarksideTests/SynchronizerDarksideTests.swift
View File

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

12
Tests/DarksideTests/SynchronizerTests.swift
View File

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

54
Tests/OfflineTests/ClosureSynchronizerOfflineTests.swift
View File

@ -638,19 +638,19 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetTransparentBalanceSucceed() {
let expectedWalletBalance = WalletBalance(verified: Zatoshi(100), total: Zatoshi(200))
let expectedBalance = AccountBalance(saplingBalance: .zero, unshielded: Zatoshi(200))
synchronizerMock.getTransparentBalanceAccountIndexClosure = { receivedAccountIndex in
synchronizerMock.getAccountBalanceAccountIndexClosure = { receivedAccountIndex in
XCTAssertEqual(receivedAccountIndex, 3)
return expectedWalletBalance
return expectedBalance
}
let expectation = XCTestExpectation()
synchronizer.getTransparentBalance(accountIndex: 3) { result in
synchronizer.getAccountBalance(accountIndex: 3) { result in
switch result {
case let .success(receivedBalance):
XCTAssertEqual(receivedBalance, expectedWalletBalance)
XCTAssertEqual(receivedBalance, expectedBalance)
expectation.fulfill()
case let .failure(error):
XCTFail("Unpected failure with error: \(error)")
@ -661,13 +661,13 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetTransparentBalanceThrowsError() {
synchronizerMock.getTransparentBalanceAccountIndexClosure = { _ in
synchronizerMock.getAccountBalanceAccountIndexClosure = { _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.getTransparentBalance(accountIndex: 3) { result in
synchronizer.getAccountBalance(accountIndex: 3) { result in
switch result {
case .success:
XCTFail("Error should be thrown.")
@ -680,17 +680,25 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedBalanceSucceed() {
synchronizerMock.getShieldedBalanceAccountIndexClosure = { receivedAccountIndex in
let expectedBalance = AccountBalance(
saplingBalance:
PoolBalance(
spendableValue: Zatoshi(333),
changePendingConfirmation: .zero,
valuePendingSpendability: .zero), unshielded: .zero
)
synchronizerMock.getAccountBalanceAccountIndexClosure = { receivedAccountIndex in
XCTAssertEqual(receivedAccountIndex, 3)
return Zatoshi(333)
return expectedBalance
}
let expectation = XCTestExpectation()
synchronizer.getShieldedBalance(accountIndex: 3) { result in
synchronizer.getAccountBalance(accountIndex: 3) { result in
switch result {
case let .success(receivedBalance):
XCTAssertEqual(receivedBalance, Zatoshi(333))
XCTAssertEqual(receivedBalance, expectedBalance)
expectation.fulfill()
case let .failure(error):
XCTFail("Unpected failure with error: \(error)")
@ -701,13 +709,13 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedBalanceThrowsError() {
synchronizerMock.getShieldedBalanceAccountIndexClosure = { _ in
synchronizerMock.getAccountBalanceAccountIndexClosure = { _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.getShieldedBalance(accountIndex: 3) { result in
synchronizer.getAccountBalance(accountIndex: 3) { result in
switch result {
case .success:
XCTFail("Error should be thrown.")
@ -720,17 +728,25 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedVerifiedBalanceSucceed() {
synchronizerMock.getShieldedVerifiedBalanceAccountIndexClosure = { receivedAccountIndex in
let expectedBalance = AccountBalance(
saplingBalance:
PoolBalance(
spendableValue: .zero,
changePendingConfirmation: Zatoshi(333),
valuePendingSpendability: .zero), unshielded: .zero
)
synchronizerMock.getAccountBalanceAccountIndexClosure = { receivedAccountIndex in
XCTAssertEqual(receivedAccountIndex, 3)
return Zatoshi(333)
return expectedBalance
}
let expectation = XCTestExpectation()
synchronizer.getShieldedVerifiedBalance(accountIndex: 3) { result in
synchronizer.getAccountBalance(accountIndex: 3) { result in
switch result {
case let .success(receivedBalance):
XCTAssertEqual(receivedBalance, Zatoshi(333))
XCTAssertEqual(receivedBalance, expectedBalance)
expectation.fulfill()
case let .failure(error):
XCTFail("Unpected failure with error: \(error)")
@ -741,13 +757,13 @@ class ClosureSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedVerifiedBalanceThrowsError() {
synchronizerMock.getShieldedVerifiedBalanceAccountIndexClosure = { _ in
synchronizerMock.getAccountBalanceAccountIndexClosure = { _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.getShieldedVerifiedBalance(accountIndex: 3) { result in
synchronizer.getAccountBalance(accountIndex: 3) { result in
switch result {
case .success:
XCTFail("Error should be thrown.")

56
Tests/OfflineTests/CombineSynchronizerOfflineTests.swift
View File

@ -748,16 +748,16 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetTransparentBalanceSucceed() {
let expectedWalletBalance = WalletBalance(verified: Zatoshi(100), total: Zatoshi(200))
let expectedBalance = AccountBalance(saplingBalance: .zero, unshielded: Zatoshi(100))
synchronizerMock.getTransparentBalanceAccountIndexClosure = { receivedAccountIndex in
synchronizerMock.getAccountBalanceAccountIndexClosure = { receivedAccountIndex in
XCTAssertEqual(receivedAccountIndex, 3)
return expectedWalletBalance
return expectedBalance
}
let expectation = XCTestExpectation()
synchronizer.getTransparentBalance(accountIndex: 3)
synchronizer.getAccountBalance(accountIndex: 3)
.sink(
receiveCompletion: { result in
switch result {
@ -768,7 +768,7 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
},
receiveValue: { value in
XCTAssertEqual(value, expectedWalletBalance)
XCTAssertEqual(value, expectedBalance)
}
)
.store(in: &cancellables)
@ -777,13 +777,13 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetTransparentBalanceThrowsError() {
synchronizerMock.getTransparentBalanceAccountIndexClosure = { _ in
synchronizerMock.getAccountBalanceAccountIndexClosure = { _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.getTransparentBalance(accountIndex: 3)
synchronizer.getAccountBalance(accountIndex: 3)
.sink(
receiveCompletion: { result in
switch result {
@ -803,14 +803,23 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedBalanceSucceed() {
synchronizerMock.getShieldedBalanceAccountIndexClosure = { receivedAccountIndex in
let expectedBalance = AccountBalance(
saplingBalance:
PoolBalance(
spendableValue: .zero,
changePendingConfirmation: Zatoshi(333),
valuePendingSpendability: .zero),
unshielded: .zero
)
synchronizerMock.getAccountBalanceAccountIndexClosure = { receivedAccountIndex in
XCTAssertEqual(receivedAccountIndex, 3)
return Zatoshi(333)
return expectedBalance
}
let expectation = XCTestExpectation()
synchronizer.getShieldedBalance(accountIndex: 3)
synchronizer.getAccountBalance(accountIndex: 3)
.sink(
receiveCompletion: { result in
switch result {
@ -821,7 +830,7 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
},
receiveValue: { value in
XCTAssertEqual(value, Zatoshi(333))
XCTAssertEqual(value, expectedBalance)
}
)
.store(in: &cancellables)
@ -830,13 +839,13 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedBalanceThrowsError() {
synchronizerMock.getShieldedBalanceAccountIndexClosure = { _ in
synchronizerMock.getAccountBalanceAccountIndexClosure = { _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.getShieldedBalance(accountIndex: 3)
synchronizer.getAccountBalance(accountIndex: 3)
.sink(
receiveCompletion: { result in
switch result {
@ -856,14 +865,23 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedVerifiedBalanceSucceed() {
synchronizerMock.getShieldedVerifiedBalanceAccountIndexClosure = { receivedAccountIndex in
let expectedBalance = AccountBalance(
saplingBalance:
PoolBalance(
spendableValue: Zatoshi(333),
changePendingConfirmation: .zero,
valuePendingSpendability: .zero),
unshielded: .zero
)
synchronizerMock.getAccountBalanceAccountIndexClosure = { receivedAccountIndex in
XCTAssertEqual(receivedAccountIndex, 3)
return Zatoshi(333)
return expectedBalance
}
let expectation = XCTestExpectation()
synchronizer.getShieldedVerifiedBalance(accountIndex: 3)
synchronizer.getAccountBalance(accountIndex: 3)
.sink(
receiveCompletion: { result in
switch result {
@ -874,7 +892,7 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
},
receiveValue: { value in
XCTAssertEqual(value, Zatoshi(333))
XCTAssertEqual(value, expectedBalance)
}
)
.store(in: &cancellables)
@ -883,13 +901,13 @@ class CombineSynchronizerOfflineTests: XCTestCase {
}
func testGetShieldedVerifiedBalanceThrowsError() {
synchronizerMock.getShieldedVerifiedBalanceAccountIndexClosure = { _ in
synchronizerMock.getAccountBalanceAccountIndexClosure = { _ in
throw "Some error"
}
let expectation = XCTestExpectation()
synchronizer.getShieldedVerifiedBalance(accountIndex: 3)
synchronizer.getAccountBalance(accountIndex: 3)
.sink(
receiveCompletion: { result in
switch result {

3
Tests/OfflineTests/SynchronizerOfflineTests.swift
View File

@ -472,8 +472,7 @@ class SynchronizerOfflineTests: ZcashTestCase {
func synchronizerState(for internalSyncStatus: InternalSyncStatus) -> SynchronizerState {
SynchronizerState(
syncSessionID: .nullID,
accountBalances: .zero,
transparentBalance: .zero,
accountBalance: .zero,
internalSyncStatus: internalSyncStatus,
latestBlockHeight: .zero
)

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

@ -1599,99 +1599,27 @@ class SynchronizerMock: Synchronizer {
}
}
// MARK: - getTransparentBalance
// MARK: - getAccountBalance
var getTransparentBalanceAccountIndexThrowableError: Error?
var getTransparentBalanceAccountIndexCallsCount = 0
var getTransparentBalanceAccountIndexCalled: Bool {
return getTransparentBalanceAccountIndexCallsCount > 0
var getAccountBalanceAccountIndexThrowableError: Error?
var getAccountBalanceAccountIndexCallsCount = 0
var getAccountBalanceAccountIndexCalled: Bool {
return getAccountBalanceAccountIndexCallsCount > 0
}
var getTransparentBalanceAccountIndexReceivedAccountIndex: Int?
var getTransparentBalanceAccountIndexReturnValue: WalletBalance!
var getTransparentBalanceAccountIndexClosure: ((Int) async throws -> WalletBalance)?
var getAccountBalanceAccountIndexReceivedAccountIndex: Int?
var getAccountBalanceAccountIndexReturnValue: AccountBalance?
var getAccountBalanceAccountIndexClosure: ((Int) async throws -> AccountBalance?)?
func getTransparentBalance(accountIndex: Int) async throws -> WalletBalance {
if let error = getTransparentBalanceAccountIndexThrowableError {
func getAccountBalance(accountIndex: Int) async throws -> AccountBalance? {
if let error = getAccountBalanceAccountIndexThrowableError {
throw error
}
getTransparentBalanceAccountIndexCallsCount += 1
getTransparentBalanceAccountIndexReceivedAccountIndex = accountIndex
if let closure = getTransparentBalanceAccountIndexClosure {
getAccountBalanceAccountIndexCallsCount += 1
getAccountBalanceAccountIndexReceivedAccountIndex = accountIndex
if let closure = getAccountBalanceAccountIndexClosure {
return try await closure(accountIndex)
} else {
return getTransparentBalanceAccountIndexReturnValue
}
}
// MARK: - getShieldedBalance
var getShieldedBalanceAccountIndexThrowableError: Error?
var getShieldedBalanceAccountIndexCallsCount = 0
var getShieldedBalanceAccountIndexCalled: Bool {
return getShieldedBalanceAccountIndexCallsCount > 0
}
var getShieldedBalanceAccountIndexReceivedAccountIndex: Int?
var getShieldedBalanceAccountIndexReturnValue: Zatoshi!
var getShieldedBalanceAccountIndexClosure: ((Int) async throws -> Zatoshi)?
func getShieldedBalance(accountIndex: Int) async throws -> Zatoshi {
if let error = getShieldedBalanceAccountIndexThrowableError {
throw error
}
getShieldedBalanceAccountIndexCallsCount += 1
getShieldedBalanceAccountIndexReceivedAccountIndex = accountIndex
if let closure = getShieldedBalanceAccountIndexClosure {
return try await closure(accountIndex)
} else {
return getShieldedBalanceAccountIndexReturnValue
}
}
// MARK: - getShieldedVerifiedBalance
var getShieldedVerifiedBalanceAccountIndexThrowableError: Error?
var getShieldedVerifiedBalanceAccountIndexCallsCount = 0
var getShieldedVerifiedBalanceAccountIndexCalled: Bool {
return getShieldedVerifiedBalanceAccountIndexCallsCount > 0
}
var getShieldedVerifiedBalanceAccountIndexReceivedAccountIndex: Int?
var getShieldedVerifiedBalanceAccountIndexReturnValue: Zatoshi!
var getShieldedVerifiedBalanceAccountIndexClosure: ((Int) async throws -> Zatoshi)?
func getShieldedVerifiedBalance(accountIndex: Int) async throws -> Zatoshi {
if let error = getShieldedVerifiedBalanceAccountIndexThrowableError {
throw error
}
getShieldedVerifiedBalanceAccountIndexCallsCount += 1
getShieldedVerifiedBalanceAccountIndexReceivedAccountIndex = accountIndex
if let closure = getShieldedVerifiedBalanceAccountIndexClosure {
return try await closure(accountIndex)
} else {
return getShieldedVerifiedBalanceAccountIndexReturnValue
}
}
// MARK: - getAccountBalances
var getAccountBalancesAccountIndexThrowableError: Error?
var getAccountBalancesAccountIndexCallsCount = 0
var getAccountBalancesAccountIndexCalled: Bool {
return getAccountBalancesAccountIndexCallsCount > 0
}
var getAccountBalancesAccountIndexReceivedAccountIndex: Int?
var getAccountBalancesAccountIndexReturnValue: AccountBalance?
var getAccountBalancesAccountIndexClosure: ((Int) async throws -> AccountBalance?)?
func getAccountBalances(accountIndex: Int) async throws -> AccountBalance? {
if let error = getAccountBalancesAccountIndexThrowableError {
throw error
}
getAccountBalancesAccountIndexCallsCount += 1
getAccountBalancesAccountIndexReceivedAccountIndex = accountIndex
if let closure = getAccountBalancesAccountIndexClosure {
return try await closure(accountIndex)
} else {
return getAccountBalancesAccountIndexReturnValue
return getAccountBalanceAccountIndexReturnValue
}
}

3
Tests/TestUtils/Stubs.swift
View File

@ -145,8 +145,7 @@ extension SynchronizerState {
static var mock: SynchronizerState {
SynchronizerState(
syncSessionID: .nullID,
accountBalances: .zero,
transparentBalance: WalletBalance(verified: Zatoshi(200), total: Zatoshi(300)),
accountBalance: AccountBalance(saplingBalance: .zero, unshielded: Zatoshi(200)),
internalSyncStatus: .syncing(0),
latestBlockHeight: 222222
)