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

559 lines
22 KiB
Swift
Raw Normal View History

Add darksidewalletd tests for foundTransactions notifications
2020-10-20 15:22:05 -07:00
//
// SychronizerDarksideTests.swift
// ZcashLightClientKit-Unit-Tests
//
// Created by Francisco Gindre on 10/20/20.
//
import XCTest
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
import Combine
Remove dependecy on rust sources
2022-02-28 09:03:20 -08:00
@testable import TestUtils
Add darksidewalletd tests for foundTransactions notifications
2020-10-20 15:22:05 -07:00
@testable import ZcashLightClientKit
SwiftLint Enabled on Test Folder
2021-09-23 06:26:41 -07:00
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
class SynchronizerDarksideTests: XCTestCase {
Add darksidewalletd tests for foundTransactions notifications
2020-10-20 15:22:05 -07:00
let sendAmount: Int64 = 1000
let defaultLatestHeight: BlockHeight = 663175
SwiftLint Enabled on Test Folder
2021-09-23 06:26:41 -07:00
let branchID = "2bb40e60"
let chainName = "main"
let network = DarksideWalletDNetwork()
var birthday: BlockHeight = 663150
Add darksidewalletd tests for foundTransactions notifications
2020-10-20 15:22:05 -07:00
var coordinator: TestCoordinator!
var syncedExpectation = XCTestExpectation(description: "synced")
var sentTransactionExpectation = XCTestExpectation(description: "sent")
var expectedReorgHeight: BlockHeight = 665188
var expectedRewindHeight: BlockHeight = 665188
SwiftLint Enabled on Test Folder
2021-09-23 06:26:41 -07:00
var reorgExpectation = XCTestExpectation(description: "reorg")
[#556] Rename Transaction to ZCashTransaction - Xcode's refactor feature used. Only renamed happened no logic was changed.
2023-01-23 01:01:07 -08:00
var foundTransactions: [ZcashTransaction.Overview] = []
[#801] Improve wipe implementation Closes #801 - `SDKSynchronizer.wipe()` can be now called anytime. - If the sync is in progress then the sync is first stopped and then wipe is executed. - Wipe now returns AnyPublisher which completes or fails when wipe is done. - Majority of wipe's work is to delete files. That is only operation that can throw error during wipe. This operation should succeed every time. If it fails that something is seriously wrong. When this happens the SDK can happen in inconsistent state. There is no recovery for now. Only way how to fix this is to reinstall the app in the device. - Added hooks mechanism. This is implemented in `AfterSyncHooksManager` and it is used by `CompactBlockProcessor`. It's just more organized way how to track what should happen when the sync process is canceled.
2023-02-20 01:53:04 -08:00
var cancellables: [AnyCancellable] = []
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
var idGenerator: MockSyncSessionIDGenerator!
[#462] Get rid of XCTestCase.wait
2023-03-30 10:01:47 -07:00
override func setUp() async throws {
try await super.setUp()
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
idGenerator = MockSyncSessionIDGenerator(ids: [.deadbeef])
self.coordinator = try await TestCoordinator(walletBirthday: birthday, network: network, syncSessionIDGenerator: idGenerator)
Cleanup warnings (#655) - TestCoordinator doesn't need to be used in async manner.
2022-11-28 22:40:45 -08:00
try self.coordinator.reset(saplingActivation: 663150, branchID: "e9ff75a6", chainName: "main")
Add darksidewalletd tests for foundTransactions notifications
2020-10-20 15:22:05 -07:00
}
[#677] Add support for wipe into SDK Closes #677 - Previously when keychain wanted to do wipe wallet had to do it on it's own. Which isn't good. Now wallet can simply call `synchronizer.wipe()` and it's done. - This change brings support for wipe. `Synchronizer` has new method `wipe()` which takes care of everything. All the database connections are closed. Databases are removed. `InternalSyncProgress` is reset. Change condition when wipe can run
2022-12-19 06:15:23 -08:00
[#462] Get rid of XCTestCase.wait
2023-03-30 10:01:47 -07:00
override func tearDown() async throws {
try await super.tearDown()
let coordinator = self.coordinator!
self.coordinator = nil
foundTransactions = []
cancellables = []
try await coordinator.stop()
- [#679] Implementation of the File-system based block cache (#679) Closes https://github.com/zcash/ZcashLightClientKit/issues/697 Closes https://github.com/zcash/ZcashLightClientKit/issues/720 Closes https://github.com/zcash/ZcashLightClientKit/issues/587 Closes https://github.com/zcash/ZcashLightClientKit/issues/667 Closes https://github.com/zcash/ZcashLightClientKit/issues/443 Closes https://github.com/zcash/ZcashLightClientKit/issues/754 - [#790] Fix ShieldFundsTests Closes #790 Removes comments on `ShieldFundsTests` since those issues have been fixed Depends on zcash-light-client-ffi changes that adopt newer versions of librustzcash crates `zcash_primitives 0.10`, `zcash_client_backend 0.7`, `zcash_proofs 0.10`, `zcash_client_sqlite 0.5.0`. Also allows wallets to define a shielding_threshold and will set foundations to customize minimum confirmations for balances, spends and shielding operations. **Test Bootstrapping** - `ZcashCompactBlockDescriptor`: struct that holds functions to describe blocks as filenames and compare those filenames `ZcashCompactBlockDescriptor.live` has the actual implementation but it can be replaced by mocks if needed on Tests main implementations are held under `FSCompactBlockRepository.filenameDescription` and `FSCompactBlockRepository.filenameComparison` on a separate extention `DirectoryListingProviders` provide two default implementations of listing a directory deterministically. `FileManager` does not define a sorting and needs to be done in-memory by calling `.sorted()` on the resulting collection. If this is a big toll on performance it can be changed to a POSIX implementation but this is good for now. `ZcashCompactBlockDescriptor` adds a `height` helper function to turn a filename into the height of the block stored. Implemented `func latestHeight() throws -> BlockHeight ` that returns the blockheight by querying the cache directory in a sorted fashion and getting the last value and turning the filename into a `BlockHeight` Added `Meta` struct to ZcashCompactBlock. Tests implemented: - `filterBlockFiles` - `testClearTheCache` - `testLatestHeightEmptyCacheThrows` - `testLatestHeightEmptyCacheThrowsAsync` - `testRewindEmptyCacheDoesNothing` - `testRewindEmptyCacheDoesNothingAsync` - `testWhenBlockIsStoredItFollowsTheDescribedFormat` - `testWhenBlockIsStoredItFollowsTheFilenameConvention` - `testGetLatestHeight` - `testRewindDeletesTheRightBlocks` test - `testPerformanceExample` test. This isn't a real performance test because the API doesn't work with async/await yet adopts `shield_funds` shielding threshold parameter Implements `initBlockMetadataDb` and fix tests Renames dbCache parameter to `fsBlockDbRoot`. Builds but tests don't pass. Removes cacheDb uses from code. Testing utilities still persist. Added needed information in MIGRATING and CHANGELOG. Added helper to perform deletion of legacy db and creation a the new file system backed cache. Renames parameters and changes code where needed. Network Constants turned into `enum` with static methods. DeletelastDownloadedBlock helper from initializer Removes CompactBlockStorage and CompactBlockEntity. Implements `latestCachedBlockHeight` on rustbackend. *Replaces dependencies on ZcashRustWelding with `FSMetadataStore`* This allows the tests to not depend in a particular implementation of either the MockRustBackend of or ZcashRustBackend. Also provides a way to test errors properly and switch implementations of critical areas like `writeBlocks`.
2023-02-02 08:58:12 -08:00
try? FileManager.default.removeItem(at: coordinator.databases.fsCacheDbRoot)
Add darksidewalletd tests for foundTransactions notifications
2020-10-20 15:22:05 -07:00
try? FileManager.default.removeItem(at: coordinator.databases.dataDB)
try? FileManager.default.removeItem(at: coordinator.databases.pendingDB)
}
[#831] Add SDKSynchronizer wrappers for non-async API This change introduces two new protocols: `ClosureSynchronizer` and `CombineSynchronizer`. These two protocols define API that doesn't use `async`. So the client can choose exactly which API it wants to use. This change also introduces two new objects: `ClosureSDKSynchronizer` and `CombineSDKSynchronizer`. These two implement the respective protocols mentioned above. Both are structures. Neither of these two keeps any state. Thanks to this each is very cheap to create. And usage of these two isn't mutually exclusive. So devs can really choose the best SDK API for each part of the client app. [#831] Use async inside of the SDKSynchronizer - In general lot of methods inside the `SDKSynchronizer` and `CompactBlockProcessoer` which weren't async are now async. And other changes are made because of this change. - `CompactBlockProcessor` no longer uses Combine to communicate with `SDKSynchronizer`. Reason for this is that Combine doesn't play great with async. Closure passed to `sink` isn't async. - Because of this and because of how our tests work (receiving signals from CBP directly) `CompactBlockProcessor` must be able to handle more event closures. Not just one. So it now has `eventClosures` dictionary. It's little bit strange but it works fine. - `SyncStatus` inside the `SDKSynchronizer` was previously protected by lock. Now it's protected by simple actor wrapper. - Changes in tests are minimal. Changes were mady only because `CompactBlockProcessor` changes from Combine to closures. [#831] Add tests for ClosureSDKSynchronizer - Added tests are testing in general if the `ClosuresSDKSynchronizer` is correctly calling `Synchronizer` and if the values are correctly returned. - `ClosuresSDKSynchronizer` doesn't contain any logic but it is public API and we should be sure that it works correctly. [#831] Add tests for CombineSDKSynchronizer [#831] Add changelog
2023-03-16 02:11:18 -07:00
func testFoundTransactions() async throws {
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
coordinator.synchronizer.eventStream
.map { event in
guard case let .foundTransactions(transactions, _) = event else { return nil }
return transactions
}
.compactMap { $0 }
.sink(receiveValue: { [weak self] transactions in self?.handleFoundTransactions(transactions: transactions) })
.store(in: &cancellables)
Fix DarksideWalletd tests
2021-05-18 14:22:29 -07:00
try FakeChainBuilder.buildChain(darksideWallet: self.coordinator.service, branchID: branchID, chainName: chainName)
Add darksidewalletd tests for foundTransactions notifications
2020-10-20 15:22:05 -07:00
let receivedTxHeight: BlockHeight = 663188
try coordinator.applyStaged(blockheight: receivedTxHeight + 1)
sleep(2)
let preTxExpectation = XCTestExpectation(description: "pre receive")
[#831] Add SDKSynchronizer wrappers for non-async API This change introduces two new protocols: `ClosureSynchronizer` and `CombineSynchronizer`. These two protocols define API that doesn't use `async`. So the client can choose exactly which API it wants to use. This change also introduces two new objects: `ClosureSDKSynchronizer` and `CombineSDKSynchronizer`. These two implement the respective protocols mentioned above. Both are structures. Neither of these two keeps any state. Thanks to this each is very cheap to create. And usage of these two isn't mutually exclusive. So devs can really choose the best SDK API for each part of the client app. [#831] Use async inside of the SDKSynchronizer - In general lot of methods inside the `SDKSynchronizer` and `CompactBlockProcessoer` which weren't async are now async. And other changes are made because of this change. - `CompactBlockProcessor` no longer uses Combine to communicate with `SDKSynchronizer`. Reason for this is that Combine doesn't play great with async. Closure passed to `sink` isn't async. - Because of this and because of how our tests work (receiving signals from CBP directly) `CompactBlockProcessor` must be able to handle more event closures. Not just one. So it now has `eventClosures` dictionary. It's little bit strange but it works fine. - `SyncStatus` inside the `SDKSynchronizer` was previously protected by lock. Now it's protected by simple actor wrapper. - Changes in tests are minimal. Changes were mady only because `CompactBlockProcessor` changes from Combine to closures. [#831] Add tests for ClosureSDKSynchronizer - Added tests are testing in general if the `ClosuresSDKSynchronizer` is correctly calling `Synchronizer` and if the values are correctly returned. - `ClosuresSDKSynchronizer` doesn't contain any logic but it is public API and we should be sure that it works correctly. [#831] Add tests for CombineSDKSynchronizer [#831] Add changelog
2023-03-16 02:11:18 -07:00
try await coordinator.sync(
completion: { _ in
preTxExpectation.fulfill()
},
error: self.handleError
)
Add darksidewalletd tests for foundTransactions notifications
2020-10-20 15:22:05 -07:00
wait(for: [preTxExpectation], timeout: 5)
XCTAssertEqual(self.foundTransactions.count, 2)
}
[#831] Add SDKSynchronizer wrappers for non-async API This change introduces two new protocols: `ClosureSynchronizer` and `CombineSynchronizer`. These two protocols define API that doesn't use `async`. So the client can choose exactly which API it wants to use. This change also introduces two new objects: `ClosureSDKSynchronizer` and `CombineSDKSynchronizer`. These two implement the respective protocols mentioned above. Both are structures. Neither of these two keeps any state. Thanks to this each is very cheap to create. And usage of these two isn't mutually exclusive. So devs can really choose the best SDK API for each part of the client app. [#831] Use async inside of the SDKSynchronizer - In general lot of methods inside the `SDKSynchronizer` and `CompactBlockProcessoer` which weren't async are now async. And other changes are made because of this change. - `CompactBlockProcessor` no longer uses Combine to communicate with `SDKSynchronizer`. Reason for this is that Combine doesn't play great with async. Closure passed to `sink` isn't async. - Because of this and because of how our tests work (receiving signals from CBP directly) `CompactBlockProcessor` must be able to handle more event closures. Not just one. So it now has `eventClosures` dictionary. It's little bit strange but it works fine. - `SyncStatus` inside the `SDKSynchronizer` was previously protected by lock. Now it's protected by simple actor wrapper. - Changes in tests are minimal. Changes were mady only because `CompactBlockProcessor` changes from Combine to closures. [#831] Add tests for ClosureSDKSynchronizer - Added tests are testing in general if the `ClosuresSDKSynchronizer` is correctly calling `Synchronizer` and if the values are correctly returned. - `ClosuresSDKSynchronizer` doesn't contain any logic but it is public API and we should be sure that it works correctly. [#831] Add tests for CombineSDKSynchronizer [#831] Add changelog
2023-03-16 02:11:18 -07:00
func testFoundManyTransactions() async throws {
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
self.idGenerator.ids = [.deadbeef, .beefbeef, .beefdead]
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
coordinator.synchronizer.eventStream
.map { event in
guard case let .foundTransactions(transactions, _) = event else { return nil }
return transactions
}
.compactMap { $0 }
.sink(receiveValue: { [weak self] transactions in self?.handleFoundTransactions(transactions: transactions) })
.store(in: &cancellables)
FIX - UNIQUE constraint violation when an operation failed
2020-10-26 14:57:19 -07:00
SwiftLint Enabled on Test Folder
2021-09-23 06:26:41 -07:00
try FakeChainBuilder.buildChain(darksideWallet: self.coordinator.service, branchID: branchID, chainName: chainName, length: 1000)
FIX - UNIQUE constraint violation when an operation failed
2020-10-26 14:57:19 -07:00
let receivedTxHeight: BlockHeight = 663229
try coordinator.applyStaged(blockheight: receivedTxHeight + 1)
sleep(2)
let firsTxExpectation = XCTestExpectation(description: "first sync")
[#831] Add SDKSynchronizer wrappers for non-async API This change introduces two new protocols: `ClosureSynchronizer` and `CombineSynchronizer`. These two protocols define API that doesn't use `async`. So the client can choose exactly which API it wants to use. This change also introduces two new objects: `ClosureSDKSynchronizer` and `CombineSDKSynchronizer`. These two implement the respective protocols mentioned above. Both are structures. Neither of these two keeps any state. Thanks to this each is very cheap to create. And usage of these two isn't mutually exclusive. So devs can really choose the best SDK API for each part of the client app. [#831] Use async inside of the SDKSynchronizer - In general lot of methods inside the `SDKSynchronizer` and `CompactBlockProcessoer` which weren't async are now async. And other changes are made because of this change. - `CompactBlockProcessor` no longer uses Combine to communicate with `SDKSynchronizer`. Reason for this is that Combine doesn't play great with async. Closure passed to `sink` isn't async. - Because of this and because of how our tests work (receiving signals from CBP directly) `CompactBlockProcessor` must be able to handle more event closures. Not just one. So it now has `eventClosures` dictionary. It's little bit strange but it works fine. - `SyncStatus` inside the `SDKSynchronizer` was previously protected by lock. Now it's protected by simple actor wrapper. - Changes in tests are minimal. Changes were mady only because `CompactBlockProcessor` changes from Combine to closures. [#831] Add tests for ClosureSDKSynchronizer - Added tests are testing in general if the `ClosuresSDKSynchronizer` is correctly calling `Synchronizer` and if the values are correctly returned. - `ClosuresSDKSynchronizer` doesn't contain any logic but it is public API and we should be sure that it works correctly. [#831] Add tests for CombineSDKSynchronizer [#831] Add changelog
2023-03-16 02:11:18 -07:00
try await coordinator.sync(
completion: { _ in
firsTxExpectation.fulfill()
},
error: self.handleError
)
FIX - UNIQUE constraint violation when an operation failed
2020-10-26 14:57:19 -07:00
wait(for: [firsTxExpectation], timeout: 10)
XCTAssertEqual(self.foundTransactions.count, 5)
self.foundTransactions.removeAll()
try coordinator.applyStaged(blockheight: 663900)
sleep(2)
let preTxExpectation = XCTestExpectation(description: "intermediate sync")
[#831] Add SDKSynchronizer wrappers for non-async API This change introduces two new protocols: `ClosureSynchronizer` and `CombineSynchronizer`. These two protocols define API that doesn't use `async`. So the client can choose exactly which API it wants to use. This change also introduces two new objects: `ClosureSDKSynchronizer` and `CombineSDKSynchronizer`. These two implement the respective protocols mentioned above. Both are structures. Neither of these two keeps any state. Thanks to this each is very cheap to create. And usage of these two isn't mutually exclusive. So devs can really choose the best SDK API for each part of the client app. [#831] Use async inside of the SDKSynchronizer - In general lot of methods inside the `SDKSynchronizer` and `CompactBlockProcessoer` which weren't async are now async. And other changes are made because of this change. - `CompactBlockProcessor` no longer uses Combine to communicate with `SDKSynchronizer`. Reason for this is that Combine doesn't play great with async. Closure passed to `sink` isn't async. - Because of this and because of how our tests work (receiving signals from CBP directly) `CompactBlockProcessor` must be able to handle more event closures. Not just one. So it now has `eventClosures` dictionary. It's little bit strange but it works fine. - `SyncStatus` inside the `SDKSynchronizer` was previously protected by lock. Now it's protected by simple actor wrapper. - Changes in tests are minimal. Changes were mady only because `CompactBlockProcessor` changes from Combine to closures. [#831] Add tests for ClosureSDKSynchronizer - Added tests are testing in general if the `ClosuresSDKSynchronizer` is correctly calling `Synchronizer` and if the values are correctly returned. - `ClosuresSDKSynchronizer` doesn't contain any logic but it is public API and we should be sure that it works correctly. [#831] Add tests for CombineSDKSynchronizer [#831] Add changelog
2023-03-16 02:11:18 -07:00
try await coordinator.sync(
completion: { _ in
preTxExpectation.fulfill()
},
error: self.handleError
)
FIX - UNIQUE constraint violation when an operation failed
2020-10-26 14:57:19 -07:00
wait(for: [preTxExpectation], timeout: 10)
SwiftLint Enabled on Test Folder
2021-09-23 06:26:41 -07:00
XCTAssertTrue(self.foundTransactions.isEmpty)
FIX - UNIQUE constraint violation when an operation failed
2020-10-26 14:57:19 -07:00
let findManyTxExpectation = XCTestExpectation(description: "final sync")
try coordinator.applyStaged(blockheight: 664010)
sleep(2)
[#831] Add SDKSynchronizer wrappers for non-async API This change introduces two new protocols: `ClosureSynchronizer` and `CombineSynchronizer`. These two protocols define API that doesn't use `async`. So the client can choose exactly which API it wants to use. This change also introduces two new objects: `ClosureSDKSynchronizer` and `CombineSDKSynchronizer`. These two implement the respective protocols mentioned above. Both are structures. Neither of these two keeps any state. Thanks to this each is very cheap to create. And usage of these two isn't mutually exclusive. So devs can really choose the best SDK API for each part of the client app. [#831] Use async inside of the SDKSynchronizer - In general lot of methods inside the `SDKSynchronizer` and `CompactBlockProcessoer` which weren't async are now async. And other changes are made because of this change. - `CompactBlockProcessor` no longer uses Combine to communicate with `SDKSynchronizer`. Reason for this is that Combine doesn't play great with async. Closure passed to `sink` isn't async. - Because of this and because of how our tests work (receiving signals from CBP directly) `CompactBlockProcessor` must be able to handle more event closures. Not just one. So it now has `eventClosures` dictionary. It's little bit strange but it works fine. - `SyncStatus` inside the `SDKSynchronizer` was previously protected by lock. Now it's protected by simple actor wrapper. - Changes in tests are minimal. Changes were mady only because `CompactBlockProcessor` changes from Combine to closures. [#831] Add tests for ClosureSDKSynchronizer - Added tests are testing in general if the `ClosuresSDKSynchronizer` is correctly calling `Synchronizer` and if the values are correctly returned. - `ClosuresSDKSynchronizer` doesn't contain any logic but it is public API and we should be sure that it works correctly. [#831] Add tests for CombineSDKSynchronizer [#831] Add changelog
2023-03-16 02:11:18 -07:00
try await coordinator.sync(
completion: { _ in
findManyTxExpectation.fulfill()
},
error: self.handleError
)
FIX - UNIQUE constraint violation when an operation failed
2020-10-26 14:57:19 -07:00
wait(for: [findManyTxExpectation], timeout: 10)
XCTAssertEqual(self.foundTransactions.count, 2)
}
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
[#831] Add SDKSynchronizer wrappers for non-async API This change introduces two new protocols: `ClosureSynchronizer` and `CombineSynchronizer`. These two protocols define API that doesn't use `async`. So the client can choose exactly which API it wants to use. This change also introduces two new objects: `ClosureSDKSynchronizer` and `CombineSDKSynchronizer`. These two implement the respective protocols mentioned above. Both are structures. Neither of these two keeps any state. Thanks to this each is very cheap to create. And usage of these two isn't mutually exclusive. So devs can really choose the best SDK API for each part of the client app. [#831] Use async inside of the SDKSynchronizer - In general lot of methods inside the `SDKSynchronizer` and `CompactBlockProcessoer` which weren't async are now async. And other changes are made because of this change. - `CompactBlockProcessor` no longer uses Combine to communicate with `SDKSynchronizer`. Reason for this is that Combine doesn't play great with async. Closure passed to `sink` isn't async. - Because of this and because of how our tests work (receiving signals from CBP directly) `CompactBlockProcessor` must be able to handle more event closures. Not just one. So it now has `eventClosures` dictionary. It's little bit strange but it works fine. - `SyncStatus` inside the `SDKSynchronizer` was previously protected by lock. Now it's protected by simple actor wrapper. - Changes in tests are minimal. Changes were mady only because `CompactBlockProcessor` changes from Combine to closures. [#831] Add tests for ClosureSDKSynchronizer - Added tests are testing in general if the `ClosuresSDKSynchronizer` is correctly calling `Synchronizer` and if the values are correctly returned. - `ClosuresSDKSynchronizer` doesn't contain any logic but it is public API and we should be sure that it works correctly. [#831] Add tests for CombineSDKSynchronizer [#831] Add changelog
2023-03-16 02:11:18 -07:00
func testLastStates() async throws {
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
self.idGenerator.ids = [.deadbeef]
var cancellables: [AnyCancellable] = []
var states: [SynchronizerState] = []
try FakeChainBuilder.buildChain(darksideWallet: self.coordinator.service, branchID: branchID, chainName: chainName)
let receivedTxHeight: BlockHeight = 663188
try coordinator.applyStaged(blockheight: receivedTxHeight + 1)
sleep(2)
let preTxExpectation = XCTestExpectation(description: "pre receive")
coordinator.synchronizer.stateStream
.sink { state in
states.append(state)
}
.store(in: &cancellables)
try await coordinator.sync(
completion: { _ in
preTxExpectation.fulfill()
},
error: self.handleError
)
wait(for: [preTxExpectation], timeout: 5)
let uuids = self.idGenerator.ids
let expectedStates: [SynchronizerState] = [
SynchronizerState(
syncSessionID: .nullID,
shieldedBalance: .zero,
transparentBalance: .zero,
syncStatus: .disconnected,
latestScannedHeight: 663150
),
SynchronizerState(
syncSessionID: uuids[0],
shieldedBalance: .zero,
transparentBalance: .zero,
syncStatus: .syncing(BlockProgress(startHeight: 0, targetHeight: 0, progressHeight: 0)),
latestScannedHeight: 663150
),
SynchronizerState(
syncSessionID: uuids[0],
shieldedBalance: .zero,
transparentBalance: .zero,
syncStatus: .syncing(BlockProgress(startHeight: 663150, targetHeight: 663189, progressHeight: 663189)),
latestScannedHeight: 663150
),
SynchronizerState(
syncSessionID: uuids[0],
shieldedBalance: WalletBalance(verified: Zatoshi(100000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .enhancing(EnhancementProgress(totalTransactions: 0, enhancedTransactions: 0, lastFoundTransaction: nil, range: 0...0)),
latestScannedHeight: 663150
),
SynchronizerState(
syncSessionID: uuids[0],
shieldedBalance: WalletBalance(verified: Zatoshi(100000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .enhancing(
EnhancementProgress(
totalTransactions: 2,
enhancedTransactions: 1,
lastFoundTransaction: ZcashTransaction.Overview(
blockTime: 1.0,
expiryHeight: 663206,
fee: Zatoshi(0),
id: 2,
index: 1,
isWalletInternal: true,
hasChange: false,
memoCount: 1,
minedHeight: 663188,
raw: Data(),
rawID: Data(),
receivedNoteCount: 1,
sentNoteCount: 0,
value: Zatoshi(100000)
),
range: 663150...663189
)
),
latestScannedHeight: 663150
),
SynchronizerState(
syncSessionID: uuids[0],
shieldedBalance: WalletBalance(verified: Zatoshi(100000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .enhancing(
EnhancementProgress(
totalTransactions: 2,
enhancedTransactions: 2,
lastFoundTransaction: ZcashTransaction.Overview(
blockTime: 1.0,
expiryHeight: 663192,
fee: Zatoshi(0),
id: 1,
index: 1,
isWalletInternal: true,
hasChange: false,
memoCount: 1,
minedHeight: 663174,
raw: Data(),
rawID: Data(),
receivedNoteCount: 1,
sentNoteCount: 0,
value: Zatoshi(100000)
),
range: 663150...663189
)
),
latestScannedHeight: 663150
),
SynchronizerState(
syncSessionID: uuids[0],
shieldedBalance: WalletBalance(verified: Zatoshi(100000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .fetching,
latestScannedHeight: 663150
),
SynchronizerState(
syncSessionID: uuids[0],
shieldedBalance: WalletBalance(verified: Zatoshi(100000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .synced,
latestScannedHeight: 663189
)
]
XCTAssertEqual(states, expectedStates)
}
func testSyncSessionUpdates() async throws {
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
var cancellables: [AnyCancellable] = []
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
self.idGenerator.ids = [.deadbeef, .beefbeef]
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
var states: [SynchronizerState] = []
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
try FakeChainBuilder.buildChain(darksideWallet: self.coordinator.service, branchID: branchID, chainName: chainName)
let receivedTxHeight: BlockHeight = 663188
try coordinator.applyStaged(blockheight: receivedTxHeight + 1)
sleep(2)
let preTxExpectation = XCTestExpectation(description: "pre receive")
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
coordinator.synchronizer.stateStream
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
.sink { state in
states.append(state)
}
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
.store(in: &cancellables)
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
[#831] Add SDKSynchronizer wrappers for non-async API This change introduces two new protocols: `ClosureSynchronizer` and `CombineSynchronizer`. These two protocols define API that doesn't use `async`. So the client can choose exactly which API it wants to use. This change also introduces two new objects: `ClosureSDKSynchronizer` and `CombineSDKSynchronizer`. These two implement the respective protocols mentioned above. Both are structures. Neither of these two keeps any state. Thanks to this each is very cheap to create. And usage of these two isn't mutually exclusive. So devs can really choose the best SDK API for each part of the client app. [#831] Use async inside of the SDKSynchronizer - In general lot of methods inside the `SDKSynchronizer` and `CompactBlockProcessoer` which weren't async are now async. And other changes are made because of this change. - `CompactBlockProcessor` no longer uses Combine to communicate with `SDKSynchronizer`. Reason for this is that Combine doesn't play great with async. Closure passed to `sink` isn't async. - Because of this and because of how our tests work (receiving signals from CBP directly) `CompactBlockProcessor` must be able to handle more event closures. Not just one. So it now has `eventClosures` dictionary. It's little bit strange but it works fine. - `SyncStatus` inside the `SDKSynchronizer` was previously protected by lock. Now it's protected by simple actor wrapper. - Changes in tests are minimal. Changes were mady only because `CompactBlockProcessor` changes from Combine to closures. [#831] Add tests for ClosureSDKSynchronizer - Added tests are testing in general if the `ClosuresSDKSynchronizer` is correctly calling `Synchronizer` and if the values are correctly returned. - `ClosuresSDKSynchronizer` doesn't contain any logic but it is public API and we should be sure that it works correctly. [#831] Add tests for CombineSDKSynchronizer [#831] Add changelog
2023-03-16 02:11:18 -07:00
try await coordinator.sync(
completion: { _ in
preTxExpectation.fulfill()
},
error: self.handleError
)
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
wait(for: [preTxExpectation], timeout: 5)
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
let uuids = idGenerator.ids
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
let expectedStates: [SynchronizerState] = [
SynchronizerState(
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
syncSessionID: .nullID,
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
shieldedBalance: .zero,
transparentBalance: .zero,
syncStatus: .disconnected,
latestScannedHeight: 663150
),
SynchronizerState(
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
syncSessionID: uuids[0],
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
shieldedBalance: .zero,
transparentBalance: .zero,
syncStatus: .syncing(BlockProgress(startHeight: 0, targetHeight: 0, progressHeight: 0)),
latestScannedHeight: 663150
),
SynchronizerState(
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
syncSessionID: uuids[0],
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
shieldedBalance: .zero,
transparentBalance: .zero,
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
syncStatus: .syncing(BlockProgress(startHeight: 663150, targetHeight: 663189, progressHeight: 663189)),
latestScannedHeight: 663150
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
),
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
SynchronizerState(
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
syncSessionID: uuids[0],
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
shieldedBalance: WalletBalance(verified: Zatoshi(100000), total: Zatoshi(200000)),
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
syncStatus: .enhancing(EnhancementProgress(totalTransactions: 0, enhancedTransactions: 0, lastFoundTransaction: nil, range: 0...0)),
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
latestScannedHeight: 663150
),
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
SynchronizerState(
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
syncSessionID: uuids[0],
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
shieldedBalance: WalletBalance(verified: Zatoshi(100000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
syncStatus: .enhancing(
EnhancementProgress(
totalTransactions: 2,
enhancedTransactions: 1,
lastFoundTransaction: ZcashTransaction.Overview(
blockTime: 1.0,
expiryHeight: 663206,
fee: Zatoshi(0),
id: 2,
index: 1,
isWalletInternal: true,
hasChange: false,
memoCount: 1,
minedHeight: 663188,
raw: Data(),
rawID: Data(),
receivedNoteCount: 1,
sentNoteCount: 0,
value: Zatoshi(100000)
),
range: 663150...663189
)
),
latestScannedHeight: 663150
),
SynchronizerState(
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
syncSessionID: uuids[0],
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
shieldedBalance: WalletBalance(verified: Zatoshi(100000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .enhancing(
EnhancementProgress(
totalTransactions: 2,
enhancedTransactions: 2,
lastFoundTransaction: ZcashTransaction.Overview(
blockTime: 1.0,
expiryHeight: 663192,
fee: Zatoshi(0),
id: 1,
index: 1,
isWalletInternal: true,
hasChange: false,
memoCount: 1,
minedHeight: 663174,
raw: Data(),
rawID: Data(),
receivedNoteCount: 1,
sentNoteCount: 0,
value: Zatoshi(100000)
),
range: 663150...663189
)
),
latestScannedHeight: 663150
),
SynchronizerState(
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
syncSessionID: uuids[0],
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
shieldedBalance: WalletBalance(verified: Zatoshi(100000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .fetching,
latestScannedHeight: 663150
),
SynchronizerState(
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
syncSessionID: uuids[0],
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
shieldedBalance: WalletBalance(verified: Zatoshi(100000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .synced,
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
latestScannedHeight: 663189
)
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
]
XCTAssertEqual(states, expectedStates)
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
try coordinator.service.applyStaged(nextLatestHeight: 663_200)
sleep(1)
states.removeAll()
let secondSyncExpectation = XCTestExpectation(description: "second sync")
try await coordinator.sync(
completion: { _ in
secondSyncExpectation.fulfill()
},
error: self.handleError
)
wait(for: [secondSyncExpectation], timeout: 5)
let secondBatchOfExpectedStates: [SynchronizerState] = [
SynchronizerState(
syncSessionID: uuids[1],
shieldedBalance: WalletBalance(verified: Zatoshi(100000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .syncing(BlockProgress(startHeight: 0, targetHeight: 0, progressHeight: 0)),
latestScannedHeight: 663189
),
SynchronizerState(
syncSessionID: uuids[1],
shieldedBalance: WalletBalance(verified: Zatoshi(100000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .syncing(BlockProgress(startHeight: 663190, targetHeight: 663200, progressHeight: 663200)),
latestScannedHeight: 663189
),
SynchronizerState(
syncSessionID: uuids[1],
shieldedBalance: WalletBalance(verified: Zatoshi(200000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .enhancing(EnhancementProgress(totalTransactions: 0, enhancedTransactions: 0, lastFoundTransaction: nil, range: 0...0)),
latestScannedHeight: 663189
),
SynchronizerState(
syncSessionID: uuids[1],
shieldedBalance: WalletBalance(verified: Zatoshi(200000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .fetching,
latestScannedHeight: 663189
),
SynchronizerState(
syncSessionID: uuids[1],
shieldedBalance: WalletBalance(verified: Zatoshi(200000), total: Zatoshi(200000)),
transparentBalance: WalletBalance(verified: Zatoshi(0), total: Zatoshi(0)),
syncStatus: .synced,
latestScannedHeight: 663200
)
]
XCTAssertEqual(states, secondBatchOfExpectedStates)
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
}
[#677] Add support for wipe into SDK Closes #677 - Previously when keychain wanted to do wipe wallet had to do it on it's own. Which isn't good. Now wallet can simply call `synchronizer.wipe()` and it's done. - This change brings support for wipe. `Synchronizer` has new method `wipe()` which takes care of everything. All the database connections are closed. Databases are removed. `InternalSyncProgress` is reset. Change condition when wipe can run
2022-12-19 06:15:23 -08:00
[#484] Use async for TransactionsRepository Closes #484. - `TransactionRepository` has async API. `Synchronizer` and alternative APIs are updated accordingly. These methods and properties in the `Synchronizer` are async now: - `cancelSpend(transaction:)` - All the variants of the `getMemos(for:)` method. - All the variants fo the `getRecipients(for:)` method. - `allConfirmedTransactions(from:limit:)` - `pendingTransactions` - `clearedTransactions` - `sentTransactions` - `receivedTransactions`
2023-03-27 07:12:06 -07:00
func testSyncAfterWipeWorks() async throws {
[#677] Add support for wipe into SDK Closes #677 - Previously when keychain wanted to do wipe wallet had to do it on it's own. Which isn't good. Now wallet can simply call `synchronizer.wipe()` and it's done. - This change brings support for wipe. `Synchronizer` has new method `wipe()` which takes care of everything. All the database connections are closed. Databases are removed. `InternalSyncProgress` is reset. Change condition when wipe can run
2022-12-19 06:15:23 -08:00
try FakeChainBuilder.buildChain(darksideWallet: self.coordinator.service, branchID: branchID, chainName: chainName)
let receivedTxHeight: BlockHeight = 663188
try coordinator.applyStaged(blockheight: receivedTxHeight + 1)
sleep(2)
let firsSyncExpectation = XCTestExpectation(description: "first sync")
[#831] Add SDKSynchronizer wrappers for non-async API This change introduces two new protocols: `ClosureSynchronizer` and `CombineSynchronizer`. These two protocols define API that doesn't use `async`. So the client can choose exactly which API it wants to use. This change also introduces two new objects: `ClosureSDKSynchronizer` and `CombineSDKSynchronizer`. These two implement the respective protocols mentioned above. Both are structures. Neither of these two keeps any state. Thanks to this each is very cheap to create. And usage of these two isn't mutually exclusive. So devs can really choose the best SDK API for each part of the client app. [#831] Use async inside of the SDKSynchronizer - In general lot of methods inside the `SDKSynchronizer` and `CompactBlockProcessoer` which weren't async are now async. And other changes are made because of this change. - `CompactBlockProcessor` no longer uses Combine to communicate with `SDKSynchronizer`. Reason for this is that Combine doesn't play great with async. Closure passed to `sink` isn't async. - Because of this and because of how our tests work (receiving signals from CBP directly) `CompactBlockProcessor` must be able to handle more event closures. Not just one. So it now has `eventClosures` dictionary. It's little bit strange but it works fine. - `SyncStatus` inside the `SDKSynchronizer` was previously protected by lock. Now it's protected by simple actor wrapper. - Changes in tests are minimal. Changes were mady only because `CompactBlockProcessor` changes from Combine to closures. [#831] Add tests for ClosureSDKSynchronizer - Added tests are testing in general if the `ClosuresSDKSynchronizer` is correctly calling `Synchronizer` and if the values are correctly returned. - `ClosuresSDKSynchronizer` doesn't contain any logic but it is public API and we should be sure that it works correctly. [#831] Add tests for CombineSDKSynchronizer [#831] Add changelog
2023-03-16 02:11:18 -07:00
try await coordinator.sync(
[#677] Add support for wipe into SDK Closes #677 - Previously when keychain wanted to do wipe wallet had to do it on it's own. Which isn't good. Now wallet can simply call `synchronizer.wipe()` and it's done. - This change brings support for wipe. `Synchronizer` has new method `wipe()` which takes care of everything. All the database connections are closed. Databases are removed. `InternalSyncProgress` is reset. Change condition when wipe can run
2022-12-19 06:15:23 -08:00
completion: { _ in
firsSyncExpectation.fulfill()
},
error: self.handleError
)
wait(for: [firsSyncExpectation], timeout: 10)
[#801] Improve wipe implementation Closes #801 - `SDKSynchronizer.wipe()` can be now called anytime. - If the sync is in progress then the sync is first stopped and then wipe is executed. - Wipe now returns AnyPublisher which completes or fails when wipe is done. - Majority of wipe's work is to delete files. That is only operation that can throw error during wipe. This operation should succeed every time. If it fails that something is seriously wrong. When this happens the SDK can happen in inconsistent state. There is no recovery for now. Only way how to fix this is to reinstall the app in the device. - Added hooks mechanism. This is implemented in `AfterSyncHooksManager` and it is used by `CompactBlockProcessor`. It's just more organized way how to track what should happen when the sync process is canceled.
2023-02-20 01:53:04 -08:00
let wipeFinished = XCTestExpectation(description: "SynchronizerWipeFinished Expectation")
coordinator.synchronizer.wipe()
.sink(
receiveCompletion: { completion in
switch completion {
case .finished:
wipeFinished.fulfill()
case .failure(let error):
XCTFail("Wipe should finish successfully. \(error)")
}
},
receiveValue: {
XCTFail("No no value should be received from wipe.")
}
)
.store(in: &cancellables)
wait(for: [wipeFinished], timeout: 1)
[#677] Add support for wipe into SDK Closes #677 - Previously when keychain wanted to do wipe wallet had to do it on it's own. Which isn't good. Now wallet can simply call `synchronizer.wipe()` and it's done. - This change brings support for wipe. `Synchronizer` has new method `wipe()` which takes care of everything. All the database connections are closed. Databases are removed. `InternalSyncProgress` is reset. Change condition when wipe can run
2022-12-19 06:15:23 -08:00
[#831] Add SDKSynchronizer wrappers for non-async API This change introduces two new protocols: `ClosureSynchronizer` and `CombineSynchronizer`. These two protocols define API that doesn't use `async`. So the client can choose exactly which API it wants to use. This change also introduces two new objects: `ClosureSDKSynchronizer` and `CombineSDKSynchronizer`. These two implement the respective protocols mentioned above. Both are structures. Neither of these two keeps any state. Thanks to this each is very cheap to create. And usage of these two isn't mutually exclusive. So devs can really choose the best SDK API for each part of the client app. [#831] Use async inside of the SDKSynchronizer - In general lot of methods inside the `SDKSynchronizer` and `CompactBlockProcessoer` which weren't async are now async. And other changes are made because of this change. - `CompactBlockProcessor` no longer uses Combine to communicate with `SDKSynchronizer`. Reason for this is that Combine doesn't play great with async. Closure passed to `sink` isn't async. - Because of this and because of how our tests work (receiving signals from CBP directly) `CompactBlockProcessor` must be able to handle more event closures. Not just one. So it now has `eventClosures` dictionary. It's little bit strange but it works fine. - `SyncStatus` inside the `SDKSynchronizer` was previously protected by lock. Now it's protected by simple actor wrapper. - Changes in tests are minimal. Changes were mady only because `CompactBlockProcessor` changes from Combine to closures. [#831] Add tests for ClosureSDKSynchronizer - Added tests are testing in general if the `ClosuresSDKSynchronizer` is correctly calling `Synchronizer` and if the values are correctly returned. - `ClosuresSDKSynchronizer` doesn't contain any logic but it is public API and we should be sure that it works correctly. [#831] Add tests for CombineSDKSynchronizer [#831] Add changelog
2023-03-16 02:11:18 -07:00
_ = try await coordinator.prepare(seed: Environment.seedBytes)
[#677] Add support for wipe into SDK Closes #677 - Previously when keychain wanted to do wipe wallet had to do it on it's own. Which isn't good. Now wallet can simply call `synchronizer.wipe()` and it's done. - This change brings support for wipe. `Synchronizer` has new method `wipe()` which takes care of everything. All the database connections are closed. Databases are removed. `InternalSyncProgress` is reset. Change condition when wipe can run
2022-12-19 06:15:23 -08:00
let secondSyncExpectation = XCTestExpectation(description: "second sync")
[#831] Add SDKSynchronizer wrappers for non-async API This change introduces two new protocols: `ClosureSynchronizer` and `CombineSynchronizer`. These two protocols define API that doesn't use `async`. So the client can choose exactly which API it wants to use. This change also introduces two new objects: `ClosureSDKSynchronizer` and `CombineSDKSynchronizer`. These two implement the respective protocols mentioned above. Both are structures. Neither of these two keeps any state. Thanks to this each is very cheap to create. And usage of these two isn't mutually exclusive. So devs can really choose the best SDK API for each part of the client app. [#831] Use async inside of the SDKSynchronizer - In general lot of methods inside the `SDKSynchronizer` and `CompactBlockProcessoer` which weren't async are now async. And other changes are made because of this change. - `CompactBlockProcessor` no longer uses Combine to communicate with `SDKSynchronizer`. Reason for this is that Combine doesn't play great with async. Closure passed to `sink` isn't async. - Because of this and because of how our tests work (receiving signals from CBP directly) `CompactBlockProcessor` must be able to handle more event closures. Not just one. So it now has `eventClosures` dictionary. It's little bit strange but it works fine. - `SyncStatus` inside the `SDKSynchronizer` was previously protected by lock. Now it's protected by simple actor wrapper. - Changes in tests are minimal. Changes were mady only because `CompactBlockProcessor` changes from Combine to closures. [#831] Add tests for ClosureSDKSynchronizer - Added tests are testing in general if the `ClosuresSDKSynchronizer` is correctly calling `Synchronizer` and if the values are correctly returned. - `ClosuresSDKSynchronizer` doesn't contain any logic but it is public API and we should be sure that it works correctly. [#831] Add tests for CombineSDKSynchronizer [#831] Add changelog
2023-03-16 02:11:18 -07:00
try await coordinator.sync(
[#677] Add support for wipe into SDK Closes #677 - Previously when keychain wanted to do wipe wallet had to do it on it's own. Which isn't good. Now wallet can simply call `synchronizer.wipe()` and it's done. - This change brings support for wipe. `Synchronizer` has new method `wipe()` which takes care of everything. All the database connections are closed. Databases are removed. `InternalSyncProgress` is reset. Change condition when wipe can run
2022-12-19 06:15:23 -08:00
completion: { _ in
secondSyncExpectation.fulfill()
},
error: self.handleError
)
wait(for: [secondSyncExpectation], timeout: 10)
}
FIX - UNIQUE constraint violation when an operation failed
2020-10-26 14:57:19 -07:00
[#724] Switch from NotificationCenter to Combine Closes #724 - All the notifications are gone. Only `synchronizerConnectionStateChanged` stayed because it's used internally. Let's deal with this one in another task. - Synchronizer has now two new publishers (`stateStream` and (`eventStream`) which are used to notify the client app about what is going on. These publishers replace notifications. - There is also new property `latestState` which can be used to get the SDK state in synchronous manner. - `SDKSynchronizer.status` is no longer public. It is used internally to refresh `latestState` and emit new values from `stateStream. - When `SDKSynchronizer.status` is update `notify()` function is triggered. And this function is now responsible for generating new snapshot of `SynchronizerState` and updating `latestState` and `stateStream`.
2023-03-15 04:17:43 -07:00
func handleFoundTransactions(transactions: [ZcashTransaction.Overview]) {
Add darksidewalletd tests for foundTransactions notifications
2020-10-20 15:22:05 -07:00
self.foundTransactions.append(contentsOf: transactions)
}
[#831] Add SDKSynchronizer wrappers for non-async API This change introduces two new protocols: `ClosureSynchronizer` and `CombineSynchronizer`. These two protocols define API that doesn't use `async`. So the client can choose exactly which API it wants to use. This change also introduces two new objects: `ClosureSDKSynchronizer` and `CombineSDKSynchronizer`. These two implement the respective protocols mentioned above. Both are structures. Neither of these two keeps any state. Thanks to this each is very cheap to create. And usage of these two isn't mutually exclusive. So devs can really choose the best SDK API for each part of the client app. [#831] Use async inside of the SDKSynchronizer - In general lot of methods inside the `SDKSynchronizer` and `CompactBlockProcessoer` which weren't async are now async. And other changes are made because of this change. - `CompactBlockProcessor` no longer uses Combine to communicate with `SDKSynchronizer`. Reason for this is that Combine doesn't play great with async. Closure passed to `sink` isn't async. - Because of this and because of how our tests work (receiving signals from CBP directly) `CompactBlockProcessor` must be able to handle more event closures. Not just one. So it now has `eventClosures` dictionary. It's little bit strange but it works fine. - `SyncStatus` inside the `SDKSynchronizer` was previously protected by lock. Now it's protected by simple actor wrapper. - Changes in tests are minimal. Changes were mady only because `CompactBlockProcessor` changes from Combine to closures. [#831] Add tests for ClosureSDKSynchronizer - Added tests are testing in general if the `ClosuresSDKSynchronizer` is correctly calling `Synchronizer` and if the values are correctly returned. - `ClosuresSDKSynchronizer` doesn't contain any logic but it is public API and we should be sure that it works correctly. [#831] Add tests for CombineSDKSynchronizer [#831] Add changelog
2023-03-16 02:11:18 -07:00
func handleError(_ error: Error?) async {
_ = try? await coordinator.stop()
Add darksidewalletd tests for foundTransactions notifications
2020-10-20 15:22:05 -07:00
guard let testError = error else {
XCTFail("failed with nil error")
return
}
XCTFail("Failed with error: \(testError)")
}
}
[#621] Adds a synchronizer state subject with the last available state for this synchronizer. also reports the SychronizerState on synchonizerStarted notification. Add tests that verify the state being reported properly Fix `BlockBatchValidationTests`
2022-11-11 09:46:13 -08:00
extension Zatoshi: CustomDebugStringConvertible {
public var debugDescription: String {
"Zatoshi(\(self.amount))"
}
}
[#895] Add Sync Session ID Synchronizer State (#906) Closes #895 Add Sync Session ID to `SynchronizerState`. A SyncSession is an attempt to sync the blockchain within the lifetime of a Synchronizer. A Synchronizer can sync many times, when synced it will refresh every ~20 seconds +- random padding. each sync attempt will have a different UUID even if it's from the same instance of SDKSynchronizer. **How are SyncSessions are delimited? With `SyncStatus` changes.** changes from [`.unprepared`|`.error`|`.disconnected`|`.stopped`] to `.syncing` assign a new sessionID to the synchronizer. Any other transitions won't. `areTwoStatusesDifferent ` was refactored to a helper function of `SyncStatus` **How are IDs generated?** ID generation is not mandated but delegated to a protocol `SyncSessionIDGenerator`. Tests inject their own deterministic generator to avoid test flakiness. Default implementation of SyncSessionIDGenerator is ````Swift struct UniqueSyncSessionIDGenerator {} extension UniqueSyncSessionIDGenerator: SyncSessionIDGenerator { func nextID() -> UUID { UUID() } } ```` **SyncSession Pseudo-Atomicity and thread safety** SyncSession is a type alias of a GenericActor holding a UUID ```` typealias SyncSession = GenericActor<UUID> extension SyncSession { /// updates the current sync session to a new value with the given generator /// - Parameters generator: a `SyncSessionIDGenerator` /// - returns: the `UUID` of the newly updated value. @discardableResult func newSession(with generator: SyncSessionIDGenerator) async -> UUID { return await self.update(generator.nextID()) } } ```` Closes #895 SessionTicker struct to control session transitions. switching to `.unprepared` now makes syncID to be `.nullID`
2023-04-07 05:02:05 -07:00
extension UUID {
static let deadbeef = UUID(uuidString: "DEADBEEF-BEEF-FAFA-BEEF-FAFAFAFAFAFA")!
static let beefbeef = UUID(uuidString: "BEEFBEEF-BEEF-DEAD-BEEF-BEEFEBEEFEBE")!
static let beefdead = UUID(uuidString: "BEEFDEAD-BEEF-FAFA-DEAD-EAEAEAEAEAEA")!
}