1328 lines
50 KiB
Swift
1328 lines
50 KiB
Swift
//
|
|
// AdvancedReOrgTests.swift
|
|
// ZcashLightClientKit-Unit-Tests
|
|
//
|
|
// Created by Francisco Gindre on 5/14/20.
|
|
//
|
|
|
|
import XCTest
|
|
@testable import TestUtils
|
|
@testable import ZcashLightClientKit
|
|
|
|
// swiftlint:disable implicitly_unwrapped_optional force_unwrapping type_body_length
|
|
//@MainActor
|
|
class AdvancedReOrgTests: XCTestCase {
|
|
// TODO: Parameterize this from environment?
|
|
// swiftlint:disable:next line_length
|
|
var seedPhrase = "still champion voice habit trend flight survey between bitter process artefact blind carbon truly provide dizzy crush flush breeze blouse charge solid fish spread"
|
|
|
|
// TODO: Parameterize this from environment
|
|
let testRecipientAddress = "zs17mg40levjezevuhdp5pqrd52zere7r7vrjgdwn5sj4xsqtm20euwahv9anxmwr3y3kmwuz8k55a"
|
|
|
|
let sendAmount = Zatoshi(1000)
|
|
var birthday: BlockHeight = 663150
|
|
let defaultLatestHeight: BlockHeight = 663175
|
|
var coordinator: TestCoordinator!
|
|
var syncedExpectation = XCTestExpectation(description: "synced")
|
|
var sentTransactionExpectation = XCTestExpectation(description: "sent")
|
|
var expectedReorgHeight: BlockHeight = 665188
|
|
var expectedRewindHeight: BlockHeight = 665188
|
|
var reorgExpectation = XCTestExpectation(description: "reorg")
|
|
let branchID = "2bb40e60"
|
|
let chainName = "main"
|
|
let network = DarksideWalletDNetwork()
|
|
|
|
override func setUpWithError() throws {
|
|
try super.setUpWithError()
|
|
wait { [self] in
|
|
self.coordinator = try await TestCoordinator(
|
|
seed: seedPhrase,
|
|
walletBirthday: birthday + 50, //don't use an exact birthday, users never do.
|
|
channelProvider: ChannelProvider(),
|
|
network: network
|
|
)
|
|
try coordinator.reset(saplingActivation: 663150, branchID: self.branchID, chainName: self.chainName)
|
|
}
|
|
}
|
|
|
|
override func tearDownWithError() throws {
|
|
try super.tearDownWithError()
|
|
NotificationCenter.default.removeObserver(self)
|
|
try coordinator.stop()
|
|
try? FileManager.default.removeItem(at: coordinator.databases.cacheDB)
|
|
try? FileManager.default.removeItem(at: coordinator.databases.dataDB)
|
|
try? FileManager.default.removeItem(at: coordinator.databases.pendingDB)
|
|
}
|
|
|
|
@objc func handleReorg(_ notification: Notification) {
|
|
guard
|
|
let reorgHeight = notification.userInfo?[CompactBlockProcessorNotificationKey.reorgHeight] as? BlockHeight,
|
|
let rewindHeight = notification.userInfo?[CompactBlockProcessorNotificationKey.rewindHeight] as? BlockHeight
|
|
else {
|
|
XCTFail("empty reorg notification")
|
|
return
|
|
}
|
|
|
|
logger!.debug("--- REORG DETECTED \(reorgHeight)--- RewindHeight: \(rewindHeight)", file: #file, function: #function, line: #line)
|
|
|
|
XCTAssertEqual(reorgHeight, expectedReorgHeight)
|
|
reorgExpectation.fulfill()
|
|
}
|
|
|
|
|
|
/// pre-condition: know balances before tx at received_Tx_height arrives
|
|
/// 1. Setup w/ default dataset
|
|
/// 2. applyStaged(received_Tx_height)
|
|
/// 3. sync up to received_Tx_height
|
|
/// 3a. verify that balance is previous balance + tx amount
|
|
/// 4. get that transaction hex encoded data
|
|
/// 5. stage 5 empty blocks w/heights received_Tx_height to received_Tx_height + 3
|
|
/// 6. stage tx at received_Tx_height + 3
|
|
/// 6a. applyheight(received_Tx_height + 1)
|
|
/// 7. sync to received_Tx_height + 1
|
|
/// 8. assert that reorg happened at received_Tx_height
|
|
/// 9. verify that balance equals initial balance
|
|
/// 10. sync up to received_Tx_height + 3
|
|
/// 11. verify that balance equals initial balance + tx amount
|
|
func testReOrgChangesInboundTxMinedHeight() async throws {
|
|
hookToReOrgNotification()
|
|
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
|
|
var shouldContinue = false
|
|
let receivedTxHeight: BlockHeight = 663188
|
|
var initialTotalBalance = Zatoshi(-1)
|
|
var initialVerifiedBalance = Zatoshi(-1)
|
|
self.expectedReorgHeight = receivedTxHeight + 1
|
|
|
|
/*
|
|
precondition:know balances before tx at received_Tx_height arrives
|
|
*/
|
|
try coordinator.applyStaged(blockheight: receivedTxHeight - 1)
|
|
sleep(3)
|
|
let preTxExpectation = XCTestExpectation(description: "pre receive")
|
|
|
|
var synchronizer: SDKSynchronizer?
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(
|
|
completion: { synchro in
|
|
synchronizer = synchro
|
|
initialVerifiedBalance = synchro.initializer.getVerifiedBalance()
|
|
initialTotalBalance = synchro.initializer.getBalance()
|
|
preTxExpectation.fulfill()
|
|
shouldContinue = true
|
|
continuation.resume()
|
|
},
|
|
error: self.handleError
|
|
)
|
|
} catch {
|
|
continuation.resume(with: .failure(error))
|
|
}
|
|
}
|
|
|
|
wait(for: [preTxExpectation], timeout: 10)
|
|
|
|
guard shouldContinue else {
|
|
XCTFail("pre receive sync failed")
|
|
return
|
|
}
|
|
|
|
/*
|
|
2. applyStaged(received_Tx_height)
|
|
*/
|
|
try coordinator.applyStaged(blockheight: receivedTxHeight)
|
|
sleep(2)
|
|
|
|
/*
|
|
3. sync up to received_Tx_height
|
|
*/
|
|
let receivedTxExpectation = XCTestExpectation(description: "received tx")
|
|
var receivedTxTotalBalance = Zatoshi(-1)
|
|
var receivedTxVerifiedBalance = Zatoshi(-1)
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchro in
|
|
synchronizer = synchro
|
|
receivedTxVerifiedBalance = synchro.initializer.getVerifiedBalance()
|
|
receivedTxTotalBalance = synchro.initializer.getBalance()
|
|
receivedTxExpectation.fulfill()
|
|
continuation.resume()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(with: .failure(error))
|
|
}
|
|
}
|
|
|
|
sleep(2)
|
|
wait(for: [receivedTxExpectation], timeout: 10)
|
|
|
|
guard let syncedSynchronizer = synchronizer else {
|
|
XCTFail("nil synchronizer")
|
|
return
|
|
}
|
|
sleep(5)
|
|
guard let receivedTx = syncedSynchronizer.receivedTransactions.first, receivedTx.minedHeight == receivedTxHeight else {
|
|
XCTFail("did not receive transaction")
|
|
return
|
|
}
|
|
|
|
/*
|
|
3a. verify that balance is previous balance + tx amount
|
|
*/
|
|
XCTAssertEqual(receivedTxTotalBalance, initialTotalBalance + receivedTx.value)
|
|
XCTAssertEqual(receivedTxVerifiedBalance, initialVerifiedBalance)
|
|
|
|
/*
|
|
4. get that transaction hex encoded data
|
|
*/
|
|
guard let receivedTxData = receivedTx.raw else {
|
|
XCTFail("received tx has no raw data!")
|
|
return
|
|
}
|
|
|
|
let receivedRawTx = RawTransaction.with { rawTx in
|
|
rawTx.height = UInt64(receivedTxHeight)
|
|
rawTx.data = receivedTxData
|
|
}
|
|
|
|
/*
|
|
5. stage 5 empty blocks w/heights received_Tx_height to received_Tx_height + 4
|
|
*/
|
|
try coordinator.stageBlockCreate(height: receivedTxHeight, count: 5)
|
|
|
|
/*
|
|
6. stage tx at received_Tx_height + 3
|
|
*/
|
|
let reorgedTxheight = receivedTxHeight + 2
|
|
try coordinator.stageTransaction(receivedRawTx, at: reorgedTxheight)
|
|
|
|
/*
|
|
6a. applyheight(received_Tx_height + 1)
|
|
*/
|
|
try coordinator.applyStaged(blockheight: receivedTxHeight + 1)
|
|
|
|
sleep(2)
|
|
|
|
/*
|
|
7. sync to received_Tx_height + 1
|
|
*/
|
|
let reorgSyncexpectation = XCTestExpectation(description: "reorg expectation")
|
|
|
|
var afterReorgTxTotalBalance = Zatoshi(-1)
|
|
var afterReorgTxVerifiedBalance = Zatoshi(-1)
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(
|
|
completion: { synchronizer in
|
|
afterReorgTxTotalBalance = synchronizer.initializer.getBalance()
|
|
afterReorgTxVerifiedBalance = synchronizer.initializer.getVerifiedBalance()
|
|
reorgSyncexpectation.fulfill()
|
|
continuation.resume()
|
|
},
|
|
error: self.handleError
|
|
)
|
|
} catch {
|
|
continuation.resume(with: .failure(error))
|
|
}
|
|
}
|
|
|
|
/*
|
|
8. assert that reorg happened at received_Tx_height
|
|
*/
|
|
sleep(2)
|
|
wait(for: [reorgExpectation, reorgSyncexpectation], timeout: 5, enforceOrder: false)
|
|
|
|
/*
|
|
9. verify that balance equals initial balance
|
|
*/
|
|
XCTAssertEqual(afterReorgTxVerifiedBalance, initialVerifiedBalance)
|
|
XCTAssertEqual(afterReorgTxTotalBalance, initialTotalBalance)
|
|
|
|
/*
|
|
10. sync up to received_Tx_height + 3
|
|
*/
|
|
let finalsyncExpectation = XCTestExpectation(description: "final sync")
|
|
|
|
var finalReorgTxTotalBalance = Zatoshi(-1)
|
|
var finalReorgTxVerifiedBalance = Zatoshi(-1)
|
|
|
|
try coordinator.applyStaged(blockheight: reorgedTxheight + 1)
|
|
sleep(3)
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(
|
|
completion: { synchronizer in
|
|
finalReorgTxTotalBalance = synchronizer.initializer.getBalance()
|
|
finalReorgTxVerifiedBalance = synchronizer.initializer.getVerifiedBalance()
|
|
finalsyncExpectation.fulfill()
|
|
continuation.resume()
|
|
},
|
|
error: self.handleError
|
|
)
|
|
} catch {
|
|
continuation.resume(with: .failure(error))
|
|
}
|
|
}
|
|
|
|
wait(for: [finalsyncExpectation], timeout: 5)
|
|
sleep(3)
|
|
|
|
guard let reorgedTx = coordinator.synchronizer.receivedTransactions.first else {
|
|
XCTFail("no transactions found")
|
|
return
|
|
}
|
|
|
|
XCTAssertEqual(reorgedTx.minedHeight, reorgedTxheight)
|
|
XCTAssertEqual(initialVerifiedBalance, finalReorgTxVerifiedBalance)
|
|
XCTAssertEqual(initialTotalBalance + receivedTx.value, finalReorgTxTotalBalance)
|
|
}
|
|
|
|
|
|
/// An outbound, unconfirmed transaction in a specific block changes height in the event of a reorg
|
|
///
|
|
///
|
|
/// The wallet handles this change, reflects it appropriately in local storage, and funds remain spendable post confirmation.
|
|
///
|
|
/// Pre-conditions:
|
|
/// - Wallet has spendable funds
|
|
///
|
|
/// 1. Setup w/ default dataset
|
|
/// 2. applyStaged(received_Tx_height)
|
|
/// 3. sync up to received_Tx_height
|
|
/// 4. create transaction
|
|
/// 5. stage 10 empty blocks
|
|
/// 6. submit tx at sentTxHeight
|
|
/// a. getIncomingTx
|
|
/// b. stageTransaction(sentTx, sentTxHeight)
|
|
/// c. applyheight(sentTxHeight + 1 )
|
|
/// 7. sync to sentTxHeight + 2
|
|
/// 8. stage sentTx and otherTx at sentTxheight
|
|
/// 9. applyStaged(sentTx + 2)
|
|
/// 10. sync up to received_Tx_height + 2
|
|
/// 11. verify that the sent tx is mined and balance is correct
|
|
/// 12. applyStaged(sentTx + 10)
|
|
/// 13. verify that there's no more pending transaction
|
|
func testReorgChangesOutboundTxIndex() async throws {
|
|
try FakeChainBuilder.buildChain(darksideWallet: self.coordinator.service, branchID: branchID, chainName: chainName)
|
|
let receivedTxHeight: BlockHeight = 663188
|
|
var initialTotalBalance = Zatoshi(-1)
|
|
|
|
/*
|
|
2. applyStaged(received_Tx_height)
|
|
*/
|
|
try coordinator.applyStaged(blockheight: receivedTxHeight)
|
|
|
|
sleep(2)
|
|
let preTxExpectation = XCTestExpectation(description: "pre receive")
|
|
|
|
/*
|
|
3. sync up to received_Tx_height
|
|
*/
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
initialTotalBalance = synchronizer.initializer.getBalance()
|
|
continuation.resume()
|
|
preTxExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [preTxExpectation], timeout: 5)
|
|
|
|
let sendExpectation = XCTestExpectation(description: "sendToAddress")
|
|
var pendingEntity: PendingTransactionEntity?
|
|
var testError: Error?
|
|
let sendAmount = Zatoshi(10000)
|
|
|
|
/*
|
|
4. create transaction
|
|
*/
|
|
do {
|
|
let pendingTx = try await coordinator.synchronizer.sendToAddress(
|
|
spendingKey: coordinator.spendingKeys!.first!,
|
|
zatoshi: sendAmount,
|
|
toAddress: try Recipient(testRecipientAddress, network: self.network.networkType),
|
|
memo: try Memo(string: "test transaction")
|
|
)
|
|
pendingEntity = pendingTx
|
|
sendExpectation.fulfill()
|
|
} catch {
|
|
testError = error
|
|
XCTFail("error sending to address. Error: \(String(describing: error))")
|
|
}
|
|
|
|
wait(for: [sendExpectation], timeout: 2)
|
|
|
|
guard let pendingTx = pendingEntity else {
|
|
XCTFail("error sending to address. Error: \(String(describing: testError))")
|
|
return
|
|
}
|
|
|
|
/*
|
|
5. stage 10 empty blocks
|
|
*/
|
|
try coordinator.stageBlockCreate(height: receivedTxHeight + 1, count: 10)
|
|
|
|
let sentTxHeight = receivedTxHeight + 1
|
|
|
|
/*
|
|
6. stage sent tx at sentTxHeight
|
|
*/
|
|
guard let sentTx = try coordinator.getIncomingTransactions()?.first else {
|
|
XCTFail("sent transaction not present on Darksidewalletd")
|
|
return
|
|
}
|
|
try coordinator.stageTransaction(sentTx, at: sentTxHeight)
|
|
|
|
/*
|
|
6a. applyheight(sentTxHeight + 1 )
|
|
*/
|
|
try coordinator.applyStaged(blockheight: sentTxHeight + 1)
|
|
|
|
sleep(2)
|
|
|
|
/*
|
|
7. sync to sentTxHeight + 1
|
|
*/
|
|
let sentTxSyncExpectation = XCTestExpectation(description: "sent tx sync expectation")
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
let pMinedHeight = synchronizer.pendingTransactions.first?.minedHeight
|
|
XCTAssertEqual(pMinedHeight, sentTxHeight)
|
|
continuation.resume()
|
|
sentTxSyncExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [sentTxSyncExpectation], timeout: 5)
|
|
|
|
/*
|
|
8. stage sentTx and otherTx at sentTxheight
|
|
*/
|
|
try coordinator.stageBlockCreate(height: sentTxHeight, count: 20, nonce: 5)
|
|
try coordinator.stageTransaction(url: FakeChainBuilder.someOtherTxUrl, at: sentTxHeight)
|
|
try coordinator.stageTransaction(sentTx, at: sentTxHeight)
|
|
|
|
/*
|
|
9. applyStaged(sentTx + 1)
|
|
*/
|
|
try coordinator.applyStaged(blockheight: sentTxHeight + 1)
|
|
|
|
sleep(2)
|
|
let afterReOrgExpectation = XCTestExpectation(description: "after ReOrg Expectation")
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
/*
|
|
11. verify that the sent tx is mined and balance is correct
|
|
*/
|
|
let pMinedHeight = synchronizer.pendingTransactions.first?.minedHeight
|
|
XCTAssertEqual(pMinedHeight, sentTxHeight)
|
|
XCTAssertEqual(initialTotalBalance - sendAmount - Zatoshi(1000), synchronizer.initializer.getBalance()) // fee change on this branch
|
|
continuation.resume()
|
|
afterReOrgExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [afterReOrgExpectation], timeout: 5)
|
|
|
|
/*
|
|
12. applyStaged(sentTx + 10)
|
|
*/
|
|
try coordinator.applyStaged(blockheight: sentTxHeight + 12)
|
|
sleep(2)
|
|
|
|
/*
|
|
13. verify that there's no more pending transaction
|
|
*/
|
|
let lastSyncExpectation = XCTestExpectation(description: "sync to confirmation")
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
lastSyncExpectation.fulfill()
|
|
continuation.resume()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [lastSyncExpectation], timeout: 5)
|
|
|
|
XCTAssertEqual(coordinator.synchronizer.pendingTransactions.count, 0)
|
|
XCTAssertEqual(initialTotalBalance - pendingTx.value - Zatoshi(1000), coordinator.synchronizer.initializer.getVerifiedBalance())
|
|
|
|
let resultingBalance: Zatoshi = coordinator.synchronizer.initializer.getBalance()
|
|
XCTAssertEqual(resultingBalance, coordinator.synchronizer.initializer.getVerifiedBalance())
|
|
}
|
|
|
|
func testIncomingTransactionIndexChange() throws {
|
|
hookToReOrgNotification()
|
|
self.expectedReorgHeight = 663196
|
|
self.expectedRewindHeight = 663175
|
|
try coordinator.reset(saplingActivation: birthday, branchID: "2bb40e60", chainName: "main")
|
|
try coordinator.resetBlocks(dataset: .predefined(dataset: .txIndexChangeBefore))
|
|
try coordinator.applyStaged(blockheight: 663195)
|
|
sleep(1)
|
|
let firstSyncExpectation = XCTestExpectation(description: "first sync expectation")
|
|
|
|
var preReorgTotalBalance = Zatoshi.zero
|
|
var preReorgVerifiedBalance = Zatoshi.zero
|
|
try coordinator.sync(completion: { synchronizer in
|
|
preReorgTotalBalance = synchronizer.initializer.getBalance()
|
|
preReorgVerifiedBalance = synchronizer.initializer.getVerifiedBalance()
|
|
firstSyncExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [firstSyncExpectation], timeout: 10)
|
|
|
|
/*
|
|
trigger reorg
|
|
*/
|
|
try coordinator.resetBlocks(dataset: .predefined(dataset: .txIndexChangeAfter))
|
|
try coordinator.applyStaged(blockheight: 663200)
|
|
|
|
sleep(1)
|
|
|
|
let afterReorgSync = XCTestExpectation(description: "after reorg sync")
|
|
|
|
var postReorgTotalBalance = Zatoshi.zero
|
|
var postReorgVerifiedBalance = Zatoshi.zero
|
|
try coordinator.sync(completion: { synchronizer in
|
|
postReorgTotalBalance = synchronizer.initializer.getBalance()
|
|
postReorgVerifiedBalance = synchronizer.initializer.getVerifiedBalance()
|
|
afterReorgSync.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [reorgExpectation, afterReorgSync], timeout: 30)
|
|
|
|
XCTAssertEqual(postReorgVerifiedBalance, preReorgVerifiedBalance)
|
|
XCTAssertEqual(postReorgTotalBalance, preReorgTotalBalance)
|
|
}
|
|
|
|
func testReOrgExpiresInboundTransaction() throws {
|
|
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
|
|
let receivedTxHeight = BlockHeight(663188)
|
|
try coordinator.applyStaged(blockheight: receivedTxHeight - 1)
|
|
sleep(2)
|
|
let expectation = XCTestExpectation(description: "sync to \(receivedTxHeight - 1) expectation")
|
|
var initialBalance = Zatoshi(-1)
|
|
var initialVerifiedBalance = Zatoshi(-1)
|
|
try coordinator.sync(completion: { synchronizer in
|
|
initialBalance = synchronizer.initializer.getBalance()
|
|
initialVerifiedBalance = synchronizer.initializer.getVerifiedBalance()
|
|
expectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [expectation], timeout: 5)
|
|
|
|
let afterTxHeight = receivedTxHeight + 1
|
|
try coordinator.applyStaged(blockheight: afterTxHeight)
|
|
sleep(2)
|
|
let afterTxSyncExpectation = XCTestExpectation(description: "sync to \(afterTxHeight) expectation")
|
|
|
|
var afterTxBalance = Zatoshi(-1)
|
|
var afterTxVerifiedBalance = Zatoshi(-1)
|
|
try coordinator.sync(completion: { synchronizer in
|
|
afterTxBalance = synchronizer.initializer.getBalance()
|
|
afterTxVerifiedBalance = synchronizer.initializer.getVerifiedBalance()
|
|
XCTAssertNotNil(
|
|
synchronizer.receivedTransactions.first { $0.minedHeight == receivedTxHeight },
|
|
"Transaction not found at \(receivedTxHeight)"
|
|
)
|
|
afterTxSyncExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [afterTxSyncExpectation], timeout: 10.0)
|
|
|
|
XCTAssertEqual(initialVerifiedBalance, afterTxVerifiedBalance)
|
|
XCTAssertNotEqual(initialBalance, afterTxBalance)
|
|
|
|
let reorgSize: Int = 3
|
|
let newBlocksCount: Int = 11 + reorgSize
|
|
try coordinator.stageBlockCreate(height: receivedTxHeight - reorgSize, count: newBlocksCount + reorgSize)
|
|
try coordinator.applyStaged(blockheight: receivedTxHeight + newBlocksCount - 1)
|
|
|
|
sleep(2)
|
|
let afterReorgExpectation = XCTestExpectation(description: "after reorg expectation")
|
|
|
|
var afterReOrgBalance = Zatoshi(-1)
|
|
var afterReOrgVerifiedBalance = Zatoshi(-1)
|
|
try coordinator.sync(completion: { synchronizer in
|
|
afterReOrgBalance = synchronizer.initializer.getBalance()
|
|
afterReOrgVerifiedBalance = synchronizer.initializer.getVerifiedBalance()
|
|
XCTAssertNil(
|
|
synchronizer.receivedTransactions.first { $0.minedHeight == receivedTxHeight },
|
|
"Transaction found at \(receivedTxHeight) after reorg"
|
|
)
|
|
afterReorgExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [afterReorgExpectation], timeout: 5)
|
|
|
|
XCTAssertEqual(afterReOrgBalance, initialBalance)
|
|
XCTAssertEqual(afterReOrgVerifiedBalance, initialVerifiedBalance)
|
|
}
|
|
|
|
|
|
/// Steps:
|
|
/// 1. sync up to an incoming transaction (incomingTxHeight + 1)
|
|
/// 1a. save balances
|
|
/// 2. stage 4 blocks from incomingTxHeight - 1 with different nonce
|
|
/// 3. stage otherTx at incomingTxHeight
|
|
/// 4. stage incomingTx at incomingTxHeight
|
|
/// 5. applyHeight(incomingHeight + 3)
|
|
/// 6. sync to latest height
|
|
/// 7. check that balances still match
|
|
func testReOrgChangesInboundTxIndexInBlock() throws {
|
|
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
|
|
|
|
let incomingTxHeight = BlockHeight(663188)
|
|
|
|
try coordinator.applyStaged(blockheight: incomingTxHeight + 1)
|
|
|
|
/*
|
|
1. sync up to an incoming transaction (incomingTxHeight + 1)
|
|
*/
|
|
let firstSyncExpectation = XCTestExpectation(description: "first sync test expectation")
|
|
|
|
var initialBalance = Zatoshi(-1)
|
|
var initialVerifiedBalance = Zatoshi(-1)
|
|
var incomingTx: ConfirmedTransactionEntity?
|
|
try coordinator.sync(completion: { _ in
|
|
firstSyncExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [firstSyncExpectation], timeout: 5)
|
|
|
|
/*
|
|
1a. save balances
|
|
*/
|
|
initialBalance = coordinator.synchronizer.initializer.getBalance()
|
|
initialVerifiedBalance = coordinator.synchronizer.initializer.getVerifiedBalance()
|
|
incomingTx = coordinator.synchronizer.receivedTransactions.first(where: { $0.minedHeight == incomingTxHeight })
|
|
|
|
guard let transaction = incomingTx else {
|
|
XCTFail("no tx found")
|
|
return
|
|
}
|
|
|
|
guard let txRawData = transaction.raw else {
|
|
XCTFail("transaction has no raw data")
|
|
return
|
|
}
|
|
|
|
let rawTransaction = RawTransaction.with({ rawTx in
|
|
rawTx.data = txRawData
|
|
})
|
|
|
|
/*
|
|
2. stage 4 blocks from incomingTxHeight - 1 with different nonce
|
|
*/
|
|
let blockCount = 4
|
|
try coordinator.stageBlockCreate(height: incomingTxHeight - 1, count: blockCount, nonce: Int.random(in: 0 ... Int.max))
|
|
|
|
/*
|
|
3. stage otherTx at incomingTxHeight
|
|
*/
|
|
try coordinator.stageTransaction(url: FakeChainBuilder.someOtherTxUrl, at: incomingTxHeight)
|
|
|
|
/*
|
|
4. stage incomingTx at incomingTxHeight
|
|
5. applyHeight(incomingHeight + 3)
|
|
6. sync to latest height
|
|
7. check that balances still match
|
|
*/
|
|
try coordinator.stageTransaction(rawTransaction, at: incomingTxHeight)
|
|
|
|
/*
|
|
5. applyHeight(incomingHeight + 2)
|
|
*/
|
|
try coordinator.applyStaged(blockheight: incomingTxHeight + 2)
|
|
|
|
let lastSyncExpectation = XCTestExpectation(description: "last sync expectation")
|
|
|
|
/*
|
|
6. sync to latest height
|
|
*/
|
|
try coordinator.sync(completion: { _ in
|
|
lastSyncExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
/*
|
|
7. check that balances still match
|
|
*/
|
|
XCTAssertEqual(coordinator.synchronizer.initializer.getVerifiedBalance(), initialVerifiedBalance)
|
|
XCTAssertEqual(coordinator.synchronizer.initializer.getBalance(), initialBalance)
|
|
|
|
wait(for: [lastSyncExpectation], timeout: 5)
|
|
}
|
|
|
|
func testTxIndexReorg() throws {
|
|
try coordinator.resetBlocks(dataset: .predefined(dataset: .txIndexChangeBefore))
|
|
|
|
let txReorgHeight = BlockHeight(663195)
|
|
let finalHeight = BlockHeight(663200)
|
|
try coordinator.applyStaged(blockheight: txReorgHeight)
|
|
let firstSyncExpectation = XCTestExpectation(description: "first sync test expectation")
|
|
var initialBalance = Zatoshi(-1)
|
|
var initialVerifiedBalance = Zatoshi(-1)
|
|
try coordinator.sync(completion: { synchronizer in
|
|
initialBalance = synchronizer.initializer.getBalance()
|
|
initialVerifiedBalance = synchronizer.initializer.getVerifiedBalance()
|
|
firstSyncExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [firstSyncExpectation], timeout: 5)
|
|
|
|
try coordinator.resetBlocks(dataset: .predefined(dataset: .txIndexChangeAfter))
|
|
|
|
try coordinator.applyStaged(blockheight: finalHeight)
|
|
|
|
let lastSyncExpectation = XCTestExpectation(description: "last sync expectation")
|
|
|
|
try coordinator.sync(completion: { _ in
|
|
lastSyncExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [lastSyncExpectation], timeout: 5)
|
|
|
|
XCTAssertEqual(coordinator.synchronizer.initializer.getBalance(), initialBalance)
|
|
XCTAssertEqual(coordinator.synchronizer.initializer.getVerifiedBalance(), initialVerifiedBalance)
|
|
}
|
|
|
|
/// A Re Org occurs and changes the height of an outbound transaction
|
|
/// Pre-condition: Wallet has funds
|
|
///
|
|
/// Steps:
|
|
/// 1. create fake chain
|
|
/// 1a. sync to latest height
|
|
/// 2. send transaction to recipient address
|
|
/// 3. getIncomingTransaction
|
|
/// 4. stage transaction at sentTxHeight
|
|
/// 5. applyHeight(sentTxHeight)
|
|
/// 6. sync to latest height
|
|
/// 6a. verify that there's a pending transaction with a mined height of sentTxHeight
|
|
/// 7. stage 15 blocks from sentTxHeight
|
|
/// 7. a stage sent tx to sentTxHeight + 2
|
|
/// 8. applyHeight(sentTxHeight + 1) to cause a 1 block reorg
|
|
/// 9. sync to latest height
|
|
/// 10. verify that there's a pending transaction with -1 mined height
|
|
/// 11. applyHeight(sentTxHeight + 2)
|
|
/// 11a. sync to latest height
|
|
/// 12. verify that there's a pending transaction with a mined height of sentTxHeight + 2
|
|
/// 13. apply height(sentTxHeight + 15)
|
|
/// 14. sync to latest height
|
|
/// 15. verify that there's no pending transaction and that the tx is displayed on the sentTransactions collection
|
|
func testReOrgChangesOutboundTxMinedHeight() async throws {
|
|
hookToReOrgNotification()
|
|
|
|
/*
|
|
1. create fake chain
|
|
*/
|
|
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
|
|
|
|
try coordinator.applyStaged(blockheight: 663188)
|
|
sleep(2)
|
|
|
|
let firstSyncExpectation = XCTestExpectation(description: "first sync")
|
|
/*
|
|
1a. sync to latest height
|
|
*/
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
firstSyncExpectation.fulfill()
|
|
continuation.resume()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [firstSyncExpectation], timeout: 5)
|
|
|
|
sleep(1)
|
|
let initialTotalBalance: Zatoshi = coordinator.synchronizer.initializer.getBalance()
|
|
|
|
let sendExpectation = XCTestExpectation(description: "send expectation")
|
|
var pendingEntity: PendingTransactionEntity?
|
|
|
|
/*
|
|
2. send transaction to recipient address
|
|
*/
|
|
do {
|
|
let pendingTx = try await coordinator.synchronizer.sendToAddress(
|
|
spendingKey: self.coordinator.spendingKeys!.first!,
|
|
zatoshi: Zatoshi(20000),
|
|
toAddress: try Recipient(testRecipientAddress, network: self.network.networkType),
|
|
memo: try Memo(string: "this is a test")
|
|
)
|
|
pendingEntity = pendingTx
|
|
sendExpectation.fulfill()
|
|
} catch {
|
|
self.handleError(error)
|
|
}
|
|
|
|
wait(for: [sendExpectation], timeout: 11)
|
|
|
|
guard pendingEntity != nil else {
|
|
XCTFail("no pending transaction after sending")
|
|
try coordinator.stop()
|
|
return
|
|
}
|
|
|
|
/**
|
|
3. getIncomingTransaction
|
|
*/
|
|
guard let incomingTx = try coordinator.getIncomingTransactions()?.first else {
|
|
XCTFail("no incoming transaction")
|
|
try coordinator.stop()
|
|
return
|
|
}
|
|
|
|
let sentTxHeight: BlockHeight = 663189
|
|
|
|
/*
|
|
4. stage transaction at sentTxHeight
|
|
*/
|
|
try coordinator.stageBlockCreate(height: sentTxHeight)
|
|
|
|
try coordinator.stageTransaction(incomingTx, at: sentTxHeight)
|
|
|
|
/*
|
|
5. applyHeight(sentTxHeight)
|
|
*/
|
|
try coordinator.applyStaged(blockheight: sentTxHeight)
|
|
|
|
sleep(2)
|
|
|
|
/*
|
|
6. sync to latest height
|
|
*/
|
|
let secondSyncExpectation = XCTestExpectation(description: "after send expectation")
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
secondSyncExpectation.fulfill()
|
|
continuation.resume()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [secondSyncExpectation], timeout: 5)
|
|
|
|
XCTAssertEqual(coordinator.synchronizer.pendingTransactions.count, 1)
|
|
guard let afterStagePendingTx = coordinator.synchronizer.pendingTransactions.first else {
|
|
return
|
|
}
|
|
|
|
/*
|
|
6a. verify that there's a pending transaction with a mined height of sentTxHeight
|
|
*/
|
|
XCTAssertEqual(afterStagePendingTx.minedHeight, sentTxHeight)
|
|
|
|
/*
|
|
7. stage 20 blocks from sentTxHeight
|
|
*/
|
|
try coordinator.stageBlockCreate(height: sentTxHeight, count: 25)
|
|
|
|
/*
|
|
7a. stage sent tx to sentTxHeight + 2
|
|
*/
|
|
try coordinator.stageTransaction(incomingTx, at: sentTxHeight + 2)
|
|
|
|
/*
|
|
8. applyHeight(sentTxHeight + 1) to cause a 1 block reorg
|
|
*/
|
|
try coordinator.applyStaged(blockheight: sentTxHeight + 1)
|
|
sleep(2)
|
|
|
|
/*
|
|
9. sync to latest height
|
|
*/
|
|
self.expectedReorgHeight = sentTxHeight + 1
|
|
let afterReorgExpectation = XCTestExpectation(description: "after reorg sync")
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
afterReorgExpectation.fulfill()
|
|
continuation.resume()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [reorgExpectation, afterReorgExpectation], timeout: 5)
|
|
|
|
/*
|
|
10. verify that there's a pending transaction with -1 mined height
|
|
*/
|
|
guard let newPendingTx = coordinator.synchronizer.pendingTransactions.first else {
|
|
XCTFail("No pending transaction")
|
|
try coordinator.stop()
|
|
return
|
|
}
|
|
|
|
XCTAssertEqual(newPendingTx.minedHeight, BlockHeight.empty())
|
|
|
|
/*
|
|
11. applyHeight(sentTxHeight + 2)
|
|
*/
|
|
try coordinator.applyStaged(blockheight: sentTxHeight + 2)
|
|
sleep(2)
|
|
|
|
let yetAnotherExpectation = XCTestExpectation(description: "after staging expectation")
|
|
|
|
/*
|
|
11a. sync to latest height
|
|
*/
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
yetAnotherExpectation.fulfill()
|
|
continuation.resume()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [yetAnotherExpectation], timeout: 5)
|
|
|
|
/*
|
|
12. verify that there's a pending transaction with a mined height of sentTxHeight + 2
|
|
*/
|
|
XCTAssertEqual(coordinator.synchronizer.pendingTransactions.count, 1)
|
|
guard let newlyPendingTx = try coordinator.synchronizer.allPendingTransactions().first else {
|
|
XCTFail("no pending transaction")
|
|
try coordinator.stop()
|
|
return
|
|
}
|
|
|
|
XCTAssertEqual(newlyPendingTx.minedHeight, sentTxHeight + 2)
|
|
|
|
/*
|
|
13. apply height(sentTxHeight + 25)
|
|
*/
|
|
try coordinator.applyStaged(blockheight: sentTxHeight + 25)
|
|
|
|
sleep(2)
|
|
|
|
let thisIsTheLastExpectationIPromess = XCTestExpectation(description: "last sync")
|
|
|
|
/*
|
|
14. sync to latest height
|
|
*/
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
thisIsTheLastExpectationIPromess.fulfill()
|
|
continuation.resume()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [thisIsTheLastExpectationIPromess], timeout: 5)
|
|
|
|
/*
|
|
15. verify that there's no pending transaction and that the tx is displayed on the sentTransactions collection
|
|
*/
|
|
XCTAssertEqual(coordinator.synchronizer.pendingTransactions.count, 0)
|
|
XCTAssertNotNil(
|
|
coordinator.synchronizer.sentTransactions
|
|
.first(
|
|
where: { transaction in
|
|
guard let txId = transaction.rawTransactionId else { return false }
|
|
return txId == newlyPendingTx.rawTransactionId
|
|
}
|
|
),
|
|
"Sent Tx is not on sent transactions"
|
|
)
|
|
|
|
XCTAssertEqual(
|
|
initialTotalBalance - newlyPendingTx.value - Zatoshi(1000),
|
|
coordinator.synchronizer.initializer.getBalance()
|
|
)
|
|
|
|
XCTAssertEqual(
|
|
initialTotalBalance - newlyPendingTx.value - Zatoshi(1000),
|
|
coordinator.synchronizer.initializer.getVerifiedBalance()
|
|
)
|
|
}
|
|
|
|
|
|
/// Uses the zcash-hackworks data set.
|
|
|
|
/// A Re Org occurs at 663195, and sweeps an Inbound Tx that appears later on the chain.
|
|
/// Steps:
|
|
/// 1. reset dlwd
|
|
/// 2. load blocks from txHeightReOrgBefore
|
|
/// 3. applyStaged(663195)
|
|
/// 4. sync to latest height
|
|
/// 5. get balances
|
|
/// 6. load blocks from dataset txHeightReOrgBefore
|
|
/// 7. apply stage 663200
|
|
/// 8. sync to latest height
|
|
/// 9. verify that the balance is equal to the one before the reorg
|
|
func testReOrgChangesInboundMinedHeight() throws {
|
|
try coordinator.reset(saplingActivation: 663150, branchID: branchID, chainName: chainName)
|
|
sleep(2)
|
|
try coordinator.resetBlocks(dataset: .predefined(dataset: .txHeightReOrgBefore))
|
|
sleep(2)
|
|
try coordinator.applyStaged(blockheight: 663195)
|
|
sleep(2)
|
|
let firstSyncExpectation = XCTestExpectation(description: "first sync")
|
|
|
|
try coordinator.sync(completion: { _ in
|
|
firstSyncExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [firstSyncExpectation], timeout: 5)
|
|
|
|
let initialBalance: Zatoshi = coordinator.synchronizer.initializer.getBalance()
|
|
let initialVerifiedBalance: Zatoshi = coordinator.synchronizer.initializer.getVerifiedBalance()
|
|
guard let initialTxHeight = try coordinator.synchronizer.allReceivedTransactions().first?.minedHeight else {
|
|
XCTFail("no incoming transaction found!")
|
|
return
|
|
}
|
|
|
|
try coordinator.resetBlocks(dataset: .predefined(dataset: .txHeightReOrgAfter))
|
|
|
|
sleep(5)
|
|
|
|
try coordinator.applyStaged(blockheight: 663200)
|
|
|
|
sleep(6)
|
|
|
|
let afterReOrgExpectation = XCTestExpectation(description: "after reorg")
|
|
try coordinator.sync(completion: { _ in
|
|
afterReOrgExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [afterReOrgExpectation], timeout: 5)
|
|
|
|
guard let afterReOrgTxHeight = coordinator.synchronizer.receivedTransactions.first?.minedHeight else {
|
|
XCTFail("no incoming transaction found after re org!")
|
|
return
|
|
}
|
|
XCTAssertEqual(initialVerifiedBalance, coordinator.synchronizer.initializer.getVerifiedBalance())
|
|
XCTAssertEqual(initialBalance, coordinator.synchronizer.initializer.getBalance())
|
|
XCTAssert(afterReOrgTxHeight > initialTxHeight)
|
|
}
|
|
|
|
/// Re Org removes incoming transaction and is never mined
|
|
/// Steps:
|
|
/// 1. sync prior to incomingTxHeight - 1 to get balances there
|
|
/// 2. sync to latest height
|
|
/// 3. cause reorg
|
|
/// 4. sync to latest height
|
|
/// 5. verify that reorg Happened at reorgHeight
|
|
/// 6. verify that balances match initial balances
|
|
func testReOrgRemovesIncomingTxForever() throws {
|
|
hookToReOrgNotification()
|
|
try coordinator.reset(saplingActivation: 663150, branchID: branchID, chainName: chainName)
|
|
|
|
try coordinator.resetBlocks(dataset: .predefined(dataset: .txReOrgRemovesInboundTxBefore))
|
|
|
|
let reorgHeight: BlockHeight = 663195
|
|
self.expectedReorgHeight = reorgHeight
|
|
self.expectedRewindHeight = reorgHeight - 10
|
|
|
|
try coordinator.applyStaged(blockheight: reorgHeight - 1)
|
|
|
|
sleep(2)
|
|
let firstSyncExpectation = XCTestExpectation(description: "first sync")
|
|
|
|
/**
|
|
1. sync prior to incomingTxHeight - 1 to get balances there
|
|
*/
|
|
try coordinator.sync(completion: { _ in
|
|
firstSyncExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [firstSyncExpectation], timeout: 5)
|
|
|
|
let initialTotalBalance: Zatoshi = coordinator.synchronizer.initializer.getBalance()
|
|
let initialVerifiedBalance: Zatoshi = coordinator.synchronizer.initializer.getVerifiedBalance()
|
|
|
|
try coordinator.applyStaged(blockheight: reorgHeight)
|
|
|
|
let secondSyncExpectation = XCTestExpectation(description: "second sync expectation")
|
|
|
|
/**
|
|
2. sync to latest height
|
|
*/
|
|
try coordinator.sync(completion: { _ in
|
|
secondSyncExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [secondSyncExpectation], timeout: 10)
|
|
|
|
/**
|
|
3. cause reorg
|
|
*/
|
|
try coordinator.resetBlocks(dataset: .predefined(dataset: .txReOrgRemovesInboundTxAfter))
|
|
|
|
try coordinator.applyStaged(blockheight: 663200)
|
|
sleep(2)
|
|
|
|
let afterReorgSyncExpectation = XCTestExpectation(description: "after reorg expectation")
|
|
try coordinator.sync(completion: { _ in
|
|
afterReorgSyncExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
|
|
wait(for: [afterReorgSyncExpectation], timeout: 5)
|
|
|
|
XCTAssertEqual(initialVerifiedBalance, coordinator.synchronizer.initializer.getVerifiedBalance())
|
|
XCTAssertEqual(initialTotalBalance, coordinator.synchronizer.initializer.getBalance())
|
|
}
|
|
|
|
/// Transaction was included in a block, and then is not included in a block after a reorg, and expires.
|
|
/// Steps:
|
|
/// 1. create fake chain
|
|
/// 1a. sync to latest height
|
|
/// 2. send transaction to recipient address
|
|
/// 3. getIncomingTransaction
|
|
/// 4. stage transaction at sentTxHeight
|
|
/// 5. applyHeight(sentTxHeight)
|
|
/// 6. sync to latest height
|
|
/// 6a. verify that there's a pending transaction with a mined height of sentTxHeight
|
|
/// 7. stage 15 blocks from sentTxHeigth to cause a reorg
|
|
/// 8. sync to latest height
|
|
/// 9. verify that there's an expired transaction as a pending transaction
|
|
func testReOrgRemovesOutboundTxAndIsNeverMined() async throws {
|
|
hookToReOrgNotification()
|
|
|
|
/*
|
|
1. create fake chain
|
|
*/
|
|
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName)
|
|
let sentTxHeight: BlockHeight = 663195
|
|
try coordinator.applyStaged(blockheight: sentTxHeight - 1)
|
|
|
|
sleep(2)
|
|
|
|
let firstSyncExpectation = XCTestExpectation(description: "first sync")
|
|
|
|
/*
|
|
1a. sync to latest height
|
|
*/
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
|
|
continuation.resume()
|
|
firstSyncExpectation.fulfill()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [firstSyncExpectation], timeout: 10)
|
|
|
|
sleep(1)
|
|
let initialTotalBalance: Zatoshi = coordinator.synchronizer.initializer.getBalance()
|
|
|
|
let sendExpectation = XCTestExpectation(description: "send expectation")
|
|
var pendingEntity: PendingTransactionEntity?
|
|
|
|
/*
|
|
2. send transaction to recipient address
|
|
*/
|
|
do {
|
|
let pendingTx = try await coordinator.synchronizer.sendToAddress(
|
|
spendingKey: self.coordinator.spendingKeys!.first!,
|
|
zatoshi: Zatoshi(20000),
|
|
toAddress: try Recipient(testRecipientAddress, network: self.network.networkType),
|
|
memo: try! Memo(string: "this is a test")
|
|
)
|
|
pendingEntity = pendingTx
|
|
sendExpectation.fulfill()
|
|
} catch {
|
|
self.handleError(error)
|
|
}
|
|
|
|
wait(for: [sendExpectation], timeout: 11)
|
|
|
|
guard pendingEntity != nil else {
|
|
XCTFail("no pending transaction after sending")
|
|
try coordinator.stop()
|
|
return
|
|
}
|
|
|
|
/**
|
|
3. getIncomingTransaction
|
|
*/
|
|
guard let incomingTx = try coordinator.getIncomingTransactions()?.first else {
|
|
XCTFail("no incoming transaction")
|
|
try coordinator.stop()
|
|
return
|
|
}
|
|
|
|
self.expectedReorgHeight = sentTxHeight + 1
|
|
|
|
/*
|
|
4. stage transaction at sentTxHeight
|
|
*/
|
|
try coordinator.stageBlockCreate(height: sentTxHeight)
|
|
|
|
try coordinator.stageTransaction(incomingTx, at: sentTxHeight)
|
|
|
|
/*
|
|
5. applyHeight(sentTxHeight)
|
|
*/
|
|
try coordinator.applyStaged(blockheight: sentTxHeight)
|
|
|
|
sleep(2)
|
|
|
|
/*
|
|
6. sync to latest height
|
|
*/
|
|
let secondSyncExpectation = XCTestExpectation(description: "after send expectation")
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
secondSyncExpectation.fulfill()
|
|
continuation.resume()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [secondSyncExpectation], timeout: 5)
|
|
let extraBlocks = 25
|
|
try coordinator.stageBlockCreate(height: sentTxHeight, count: extraBlocks, nonce: 5)
|
|
|
|
try coordinator.applyStaged(blockheight: sentTxHeight + 5)
|
|
|
|
sleep(2)
|
|
let reorgSyncExpectation = XCTestExpectation(description: "reorg sync expectation")
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
reorgSyncExpectation.fulfill()
|
|
continuation.resume()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [reorgExpectation, reorgSyncExpectation], timeout: 5)
|
|
|
|
guard let pendingTx = coordinator.synchronizer.pendingTransactions.first else {
|
|
XCTFail("no pending transaction after reorg sync")
|
|
return
|
|
}
|
|
|
|
XCTAssertFalse(pendingTx.isMined)
|
|
|
|
LoggerProxy.info("applyStaged(blockheight: \(sentTxHeight + extraBlocks - 1))")
|
|
try coordinator.applyStaged(blockheight: sentTxHeight + extraBlocks - 1)
|
|
|
|
sleep(2)
|
|
|
|
let lastSyncExpectation = XCTestExpectation(description: "last sync expectation")
|
|
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(completion: { synchronizer in
|
|
lastSyncExpectation.fulfill()
|
|
continuation.resume()
|
|
}, error: self.handleError)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [lastSyncExpectation], timeout: 5)
|
|
|
|
XCTAssertEqual(coordinator.synchronizer.initializer.getBalance(), initialTotalBalance)
|
|
}
|
|
|
|
func testLongSync() async throws {
|
|
hookToReOrgNotification()
|
|
|
|
/*
|
|
1. create fake chain
|
|
*/
|
|
let fullSyncLength = 100_000
|
|
|
|
try FakeChainBuilder.buildChain(darksideWallet: coordinator.service, branchID: branchID, chainName: chainName, length: fullSyncLength)
|
|
|
|
try coordinator.applyStaged(blockheight: birthday + fullSyncLength)
|
|
|
|
sleep(10)
|
|
|
|
let firstSyncExpectation = XCTestExpectation(description: "first sync")
|
|
|
|
/*
|
|
sync to latest height
|
|
*/
|
|
try await withCheckedThrowingContinuation { continuation in
|
|
do {
|
|
try coordinator.sync(
|
|
completion: { _ in
|
|
firstSyncExpectation.fulfill()
|
|
continuation.resume()
|
|
}, error: { error in
|
|
_ = try? self.coordinator.stop()
|
|
firstSyncExpectation.fulfill()
|
|
guard let testError = error else {
|
|
XCTFail("failed with nil error")
|
|
return
|
|
}
|
|
XCTFail("Failed with error: \(testError)")
|
|
}
|
|
)
|
|
} catch {
|
|
continuation.resume(throwing: error)
|
|
}
|
|
}
|
|
|
|
wait(for: [firstSyncExpectation], timeout: 500)
|
|
|
|
let latestDownloadedHeight = try await coordinator.synchronizer.latestDownloadedHeight()
|
|
XCTAssertEqual(latestDownloadedHeight, birthday + fullSyncLength)
|
|
}
|
|
|
|
func handleError(_ error: Error?) {
|
|
_ = try? coordinator.stop()
|
|
guard let testError = error else {
|
|
XCTFail("failed with nil error")
|
|
return
|
|
}
|
|
XCTFail("Failed with error: \(testError)")
|
|
}
|
|
|
|
func hookToReOrgNotification() {
|
|
NotificationCenter.default.addObserver(self, selector: #selector(handleReorg(_:)), name: .blockProcessorHandledReOrg, object: nil)
|
|
}
|
|
}
|