483 lines
15 KiB
C++
Executable file
483 lines
15 KiB
C++
Executable file
// Copyright (c) 2012-2015, The CryptoNote developers, The Bytecoin developers
|
|
//
|
|
// This file is part of Bytecoin.
|
|
//
|
|
// Bytecoin is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Bytecoin is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with Bytecoin. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
#include "EventWaiter.h"
|
|
#include "Logging/ConsoleLogger.h"
|
|
#include "Transfers/BlockchainSynchronizer.h"
|
|
#include "Transfers/TransfersSynchronizer.h"
|
|
|
|
#include "INodeStubs.h"
|
|
#include "TestBlockchainGenerator.h"
|
|
#include "TransactionApiHelpers.h"
|
|
#include "CryptoNoteCore/TransactionApi.h"
|
|
|
|
#include "WalletLegacy/WalletLegacy.h"
|
|
|
|
#include <boost/scoped_array.hpp>
|
|
|
|
#include <future>
|
|
#include <algorithm>
|
|
|
|
using namespace CryptoNote;
|
|
|
|
/*
|
|
class TransfersObserver : public ITransfersObserver {
|
|
public:
|
|
|
|
virtual void onTransactionUpdated(ITransfersSubscription* object, const Hash& transactionHash,
|
|
uint64_t amountIn, uint64_t amountOut) override {
|
|
std::lock_guard<std::mutex> lk(m_mutex);
|
|
m_transfers.push_back(std::make_pair(transactionHash, amountIn - amountOut));
|
|
}
|
|
|
|
std::vector<std::pair<Hash, int64_t>> m_transfers;
|
|
std::mutex m_mutex;
|
|
}; */
|
|
|
|
|
|
class INodeStubWithPoolTx : public INodeTrivialRefreshStub {
|
|
public:
|
|
INodeStubWithPoolTx(TestBlockchainGenerator& generator) : INodeTrivialRefreshStub(generator), detached(false) {}
|
|
|
|
void relayTransaction(const CryptoNote::Transaction& transaction, const Callback& callback) override {
|
|
std::unique_lock<std::mutex> lk(mutex);
|
|
relayedTxs.push_back(std::make_pair(this->getLastLocalBlockHeight(), transaction));
|
|
lk.unlock();
|
|
INodeTrivialRefreshStub::relayTransaction(transaction, callback);
|
|
}
|
|
|
|
void startAlternativeChain(uint32_t height) override {
|
|
std::unique_lock<std::mutex> lk(mutex);
|
|
INodeTrivialRefreshStub::startAlternativeChain(height);
|
|
detachHeight = height;
|
|
detached = true;
|
|
}
|
|
|
|
|
|
void getPoolSymmetricDifference(std::vector<Crypto::Hash>&& known_pool_tx_ids, Crypto::Hash known_block_id, bool& is_bc_actual, std::vector<std::unique_ptr<CryptoNote::ITransactionReader>>& new_txs, std::vector<Crypto::Hash>& deleted_tx_ids, const Callback& callback) override
|
|
{
|
|
std::unique_lock<std::mutex> lk(mutex);
|
|
std::sort(relayedTxs.begin(), relayedTxs.end(), [](const std::pair<uint32_t, CryptoNote::Transaction>& val1, const std::pair<uint32_t, CryptoNote::Transaction>& val2)->bool {return val1.first < val2.first; });
|
|
is_bc_actual = true;
|
|
|
|
if (detached) {
|
|
size_t i = 0;
|
|
for (; i < relayedTxs.size(); ++i) {
|
|
if (relayedTxs[i].first >= detachHeight) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (; i < relayedTxs.size(); ++i) {
|
|
new_txs.push_back(CryptoNote::createTransactionPrefix(relayedTxs[i].second));
|
|
}
|
|
}
|
|
|
|
lk.unlock();
|
|
callback(std::error_code());
|
|
};
|
|
|
|
|
|
std::vector<std::pair<uint32_t, CryptoNote::Transaction>> relayedTxs;
|
|
uint32_t detachHeight;
|
|
bool detached;
|
|
std::mutex mutex;
|
|
};
|
|
|
|
class WalletSendObserver : public CryptoNote::IWalletLegacyObserver
|
|
{
|
|
public:
|
|
WalletSendObserver() {}
|
|
|
|
bool waitForSendEnd(std::error_code& ec) {
|
|
if (!sent.wait_for(std::chrono::milliseconds(5000))) return false;
|
|
ec = sendResult;
|
|
return true;
|
|
}
|
|
|
|
virtual void sendTransactionCompleted(CryptoNote::TransactionId transactionId, std::error_code result) override {
|
|
sendResult = result;
|
|
sent.notify();
|
|
}
|
|
|
|
std::error_code sendResult;
|
|
EventWaiter sent;
|
|
};
|
|
|
|
class DetachTest : public ::testing::Test, public IBlockchainSynchronizerObserver {
|
|
public:
|
|
|
|
DetachTest() :
|
|
m_currency(CryptoNote::CurrencyBuilder(m_logger).currency()),
|
|
generator(m_currency),
|
|
m_node(generator),
|
|
m_sync(m_node, m_currency.genesisBlockHash()),
|
|
m_transfersSync(m_currency, m_sync, m_node) {
|
|
}
|
|
|
|
void addAccounts(size_t count) {
|
|
while (count--) {
|
|
m_accounts.push_back(generateAccountKeys());
|
|
}
|
|
}
|
|
|
|
void addMinerAccount() {
|
|
m_accounts.push_back(reinterpret_cast<const AccountKeys&>(generator.getMinerAccount()));
|
|
}
|
|
|
|
AccountSubscription createSubscription(size_t acc, uint64_t timestamp = 0) {
|
|
const auto& keys = m_accounts[acc];
|
|
AccountSubscription sub;
|
|
sub.keys = keys;
|
|
sub.syncStart.timestamp = timestamp;
|
|
sub.syncStart.height = 0;
|
|
sub.transactionSpendableAge = 5;
|
|
return sub;
|
|
}
|
|
|
|
void subscribeAccounts() {
|
|
|
|
// m_transferObservers.reset(new TransfersObserver[m_accounts.size()]);
|
|
|
|
for (size_t i = 0; i < m_accounts.size(); ++i) {
|
|
m_subscriptions.push_back(&m_transfersSync.addSubscription(createSubscription(i)));
|
|
//m_subscriptions.back()->addObserver(&m_transferObservers[i]);
|
|
}
|
|
}
|
|
|
|
void generateMoneyForAccount(size_t idx) {
|
|
generator.getBlockRewardForAddress(
|
|
reinterpret_cast<const CryptoNote::AccountPublicAddress&>(m_accounts[idx].address));
|
|
}
|
|
|
|
std::error_code submitTransaction(ITransactionReader& tx) {
|
|
auto data = tx.getTransactionData();
|
|
|
|
CryptoNote::BinaryArray txblob(data.data(), data.data() + data.size());
|
|
CryptoNote::Transaction outTx;
|
|
fromBinaryArray(outTx, data);
|
|
std::promise<std::error_code> result;
|
|
std::future<std::error_code> future = result.get_future();
|
|
|
|
m_node.relayTransaction(outTx, [&result](std::error_code ec) {
|
|
std::promise<std::error_code> promise = std::move(result);
|
|
promise.set_value(ec);
|
|
});
|
|
|
|
return future.get();
|
|
}
|
|
|
|
void synchronizationCompleted(std::error_code result) override {
|
|
decltype(syncCompleted) detachedPromise = std::move(syncCompleted);
|
|
detachedPromise.set_value(result);
|
|
}
|
|
|
|
|
|
protected:
|
|
std::vector<AccountKeys> m_accounts;
|
|
std::vector<ITransfersSubscription*> m_subscriptions;
|
|
|
|
Logging::ConsoleLogger m_logger;
|
|
CryptoNote::Currency m_currency;
|
|
TestBlockchainGenerator generator;
|
|
INodeStubWithPoolTx m_node;
|
|
BlockchainSynchronizer m_sync;
|
|
TransfersSyncronizer m_transfersSync;
|
|
|
|
std::promise<std::error_code> syncCompleted;
|
|
std::future<std::error_code> syncCompletedFuture;
|
|
|
|
};
|
|
|
|
|
|
namespace CryptoNote {
|
|
inline bool operator == (const TransactionOutputInformation& t1, const TransactionOutputInformation& t2) {
|
|
return
|
|
t1.type == t2.type &&
|
|
t1.amount == t2.amount &&
|
|
t1.outputInTransaction == t2.outputInTransaction &&
|
|
t1.transactionPublicKey == t2.transactionPublicKey;
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
std::unique_ptr<ITransaction> createMoneyTransfer(
|
|
uint64_t amount,
|
|
uint64_t fee,
|
|
const AccountKeys& senderKeys,
|
|
const AccountPublicAddress& reciever,
|
|
ITransfersContainer& tc) {
|
|
|
|
std::vector<TransactionOutputInformation> transfers;
|
|
tc.getOutputs(transfers, ITransfersContainer::IncludeAllUnlocked);
|
|
|
|
auto tx = createTransaction();
|
|
|
|
std::vector<std::pair<TransactionTypes::InputKeyInfo, KeyPair>> inputs;
|
|
|
|
uint64_t foundMoney = 0;
|
|
|
|
for (const auto& t : transfers) {
|
|
TransactionTypes::InputKeyInfo info;
|
|
|
|
info.amount = t.amount;
|
|
|
|
TransactionTypes::GlobalOutput globalOut;
|
|
globalOut.outputIndex = t.globalOutputIndex;
|
|
globalOut.targetKey = t.outputKey;
|
|
info.outputs.push_back(globalOut);
|
|
|
|
info.realOutput.outputInTransaction = t.outputInTransaction;
|
|
info.realOutput.transactionIndex = 0;
|
|
info.realOutput.transactionPublicKey = t.transactionPublicKey;
|
|
|
|
KeyPair kp;
|
|
tx->addInput(senderKeys, info, kp);
|
|
|
|
inputs.push_back(std::make_pair(info, kp));
|
|
|
|
foundMoney += info.amount;
|
|
|
|
if (foundMoney >= amount + fee) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// output to reciever
|
|
tx->addOutput(amount, reciever);
|
|
// change
|
|
uint64_t change = foundMoney - amount - fee;
|
|
if (change) {
|
|
tx->addOutput(change, senderKeys.address);
|
|
}
|
|
|
|
for (size_t inputIdx = 0; inputIdx < inputs.size(); ++inputIdx) {
|
|
tx->signInputKey(inputIdx, inputs[inputIdx].first, inputs[inputIdx].second);
|
|
}
|
|
|
|
return tx;
|
|
}
|
|
}
|
|
|
|
|
|
TEST_F(DetachTest, testBlockchainDetach) {
|
|
uint64_t sendAmount = 70000000000000;
|
|
auto fee = m_currency.minimumFee();
|
|
|
|
addMinerAccount();
|
|
addAccounts(2);
|
|
subscribeAccounts();
|
|
|
|
generator.generateEmptyBlocks(20);
|
|
|
|
syncCompleted = std::promise<std::error_code>();
|
|
syncCompletedFuture = syncCompleted.get_future();
|
|
m_sync.addObserver(this);
|
|
m_sync.start();
|
|
syncCompletedFuture.get();
|
|
m_sync.removeObserver(this);
|
|
|
|
auto& tc = m_subscriptions[0]->getContainer();
|
|
tc.balance();
|
|
|
|
ASSERT_LE(sendAmount, tc.balance(ITransfersContainer::IncludeAllUnlocked));
|
|
|
|
auto tx = createMoneyTransfer(sendAmount, fee, m_accounts[0], m_accounts[1].address, tc);
|
|
submitTransaction(*tx);
|
|
|
|
syncCompleted = std::promise<std::error_code>();
|
|
syncCompletedFuture = syncCompleted.get_future();
|
|
m_sync.addObserver(this);
|
|
m_node.updateObservers();
|
|
syncCompletedFuture.get();
|
|
m_sync.removeObserver(this);
|
|
auto& tc2 = m_subscriptions[1]->getContainer();
|
|
|
|
ASSERT_EQ(sendAmount, tc2.balance(ITransfersContainer::IncludeAll));
|
|
ASSERT_EQ(0, tc2.balance(ITransfersContainer::IncludeAllUnlocked));
|
|
ASSERT_EQ(1, tc2.transactionsCount());
|
|
|
|
std::vector<Crypto::Hash> unconfirmed;
|
|
tc2.getUnconfirmedTransactions(unconfirmed);
|
|
ASSERT_EQ(0, unconfirmed.size());
|
|
|
|
m_node.startAlternativeChain(m_node.getLastLocalBlockHeight() - 1);
|
|
generator.generateEmptyBlocks(2);
|
|
|
|
syncCompleted = std::promise<std::error_code>();
|
|
syncCompletedFuture = syncCompleted.get_future();
|
|
m_sync.addObserver(this);
|
|
m_node.updateObservers();
|
|
syncCompletedFuture.get();
|
|
m_sync.removeObserver(this);
|
|
auto& tc3 = m_subscriptions[1]->getContainer();
|
|
|
|
ASSERT_EQ(sendAmount, tc3.balance(ITransfersContainer::IncludeAll));
|
|
ASSERT_EQ(0, tc3.balance(ITransfersContainer::IncludeAllUnlocked));
|
|
ASSERT_EQ(1, tc3.transactionsCount());
|
|
|
|
tc3.getUnconfirmedTransactions(unconfirmed);
|
|
ASSERT_EQ(1, unconfirmed.size());
|
|
ASSERT_EQ(reinterpret_cast<const Hash&>(unconfirmed[0]), tx->getTransactionHash());
|
|
m_sync.stop();
|
|
}
|
|
|
|
|
|
struct CompletionWalletObserver : public IWalletLegacyObserver {
|
|
virtual void synchronizationCompleted(std::error_code result) override {
|
|
decltype(syncCompleted) detachedPromise = std::move(syncCompleted);
|
|
detachedPromise.set_value(result);
|
|
}
|
|
|
|
std::promise<std::error_code> syncCompleted;
|
|
std::future<std::error_code> syncCompletedFuture;
|
|
};
|
|
|
|
|
|
struct WaitForExternalTransactionObserver : public CryptoNote::IWalletLegacyObserver {
|
|
public:
|
|
WaitForExternalTransactionObserver() {}
|
|
std::promise<CryptoNote::TransactionId> promise;
|
|
|
|
virtual void externalTransactionCreated(CryptoNote::TransactionId transactionId) override {
|
|
decltype(promise) detachedPromise = std::move(promise);
|
|
detachedPromise.set_value(transactionId);
|
|
}
|
|
|
|
};
|
|
|
|
TEST_F(DetachTest, testDetachWithWallet) {
|
|
auto fee = m_currency.minimumFee();
|
|
|
|
generator.generateEmptyBlocks(5);
|
|
WalletLegacy Alice(m_currency, m_node);
|
|
WalletLegacy Bob(m_currency, m_node);
|
|
|
|
CompletionWalletObserver AliceCompleted, BobCompleted;
|
|
AliceCompleted.syncCompleted = std::promise<std::error_code>();
|
|
AliceCompleted.syncCompletedFuture = AliceCompleted.syncCompleted.get_future();
|
|
BobCompleted.syncCompleted = std::promise<std::error_code>();
|
|
BobCompleted.syncCompletedFuture = BobCompleted.syncCompleted.get_future();
|
|
Alice.addObserver(&AliceCompleted);
|
|
Bob.addObserver(&BobCompleted);
|
|
Alice.initAndGenerate("pass");
|
|
Bob.initAndGenerate("pass");
|
|
AliceCompleted.syncCompletedFuture.get();
|
|
BobCompleted.syncCompletedFuture.get();
|
|
Alice.removeObserver(&AliceCompleted);
|
|
Bob.removeObserver(&BobCompleted);
|
|
|
|
|
|
AccountKeys AliceKeys;
|
|
Alice.getAccountKeys(AliceKeys);
|
|
|
|
generator.getBlockRewardForAddress(AliceKeys.address);
|
|
|
|
|
|
generator.generateEmptyBlocks(10);
|
|
|
|
AliceCompleted.syncCompleted = std::promise<std::error_code>();
|
|
AliceCompleted.syncCompletedFuture = AliceCompleted.syncCompleted.get_future();
|
|
BobCompleted.syncCompleted = std::promise<std::error_code>();
|
|
BobCompleted.syncCompletedFuture = BobCompleted.syncCompleted.get_future();
|
|
Alice.addObserver(&AliceCompleted);
|
|
Bob.addObserver(&BobCompleted);
|
|
|
|
m_node.updateObservers();
|
|
|
|
AliceCompleted.syncCompletedFuture.get();
|
|
BobCompleted.syncCompletedFuture.get();
|
|
Alice.removeObserver(&AliceCompleted);
|
|
Bob.removeObserver(&BobCompleted);
|
|
|
|
|
|
ASSERT_EQ(0, Alice.pendingBalance());
|
|
ASSERT_NE(0, Alice.actualBalance());
|
|
|
|
CryptoNote::WalletLegacyTransfer tr;
|
|
|
|
tr.amount = Alice.actualBalance() / 2;
|
|
tr.address = Bob.getAddress();
|
|
|
|
WalletSendObserver wso;
|
|
Alice.addObserver(&wso);
|
|
Alice.sendTransaction(tr, fee);
|
|
std::error_code sendError;
|
|
wso.waitForSendEnd(sendError);
|
|
Alice.removeObserver(&wso);
|
|
ASSERT_FALSE(sendError);
|
|
|
|
WaitForExternalTransactionObserver etxo;
|
|
auto externalTxFuture = etxo.promise.get_future();
|
|
Bob.addObserver(&etxo);
|
|
AliceCompleted.syncCompleted = std::promise<std::error_code>();
|
|
AliceCompleted.syncCompletedFuture = AliceCompleted.syncCompleted.get_future();
|
|
BobCompleted.syncCompleted = std::promise<std::error_code>();
|
|
BobCompleted.syncCompletedFuture = BobCompleted.syncCompleted.get_future();
|
|
Alice.addObserver(&AliceCompleted);
|
|
Bob.addObserver(&BobCompleted);
|
|
|
|
auto expectedTransactionBlockHeight = m_node.getLastLocalBlockHeight();
|
|
generator.generateEmptyBlocks(1); //unlock bob's pending money
|
|
|
|
m_node.updateObservers();
|
|
|
|
AliceCompleted.syncCompletedFuture.get();
|
|
BobCompleted.syncCompletedFuture.get();
|
|
Alice.removeObserver(&AliceCompleted);
|
|
Bob.removeObserver(&BobCompleted);
|
|
|
|
auto txId = externalTxFuture.get();
|
|
Bob.removeObserver(&etxo);
|
|
|
|
WalletLegacyTransaction txInfo;
|
|
|
|
Bob.getTransaction(txId, txInfo);
|
|
|
|
ASSERT_EQ(txInfo.blockHeight, expectedTransactionBlockHeight);
|
|
ASSERT_EQ(txInfo.totalAmount, tr.amount);
|
|
|
|
ASSERT_EQ(Bob.pendingBalance(), 0);
|
|
ASSERT_EQ(Bob.actualBalance(), tr.amount);
|
|
|
|
m_node.startAlternativeChain(txInfo.blockHeight - 1);
|
|
generator.generateEmptyBlocks(2);
|
|
|
|
//sync Bob
|
|
AliceCompleted.syncCompleted = std::promise<std::error_code>();
|
|
AliceCompleted.syncCompletedFuture = AliceCompleted.syncCompleted.get_future();
|
|
BobCompleted.syncCompleted = std::promise<std::error_code>();
|
|
BobCompleted.syncCompletedFuture = BobCompleted.syncCompleted.get_future();
|
|
Alice.addObserver(&AliceCompleted);
|
|
Bob.addObserver(&BobCompleted);
|
|
|
|
m_node.updateObservers();
|
|
|
|
AliceCompleted.syncCompletedFuture.get();
|
|
BobCompleted.syncCompletedFuture.get();
|
|
Alice.removeObserver(&AliceCompleted);
|
|
Bob.removeObserver(&BobCompleted);
|
|
|
|
Bob.getTransaction(txId, txInfo);
|
|
ASSERT_EQ(txInfo.blockHeight, WALLET_LEGACY_UNCONFIRMED_TRANSACTION_HEIGHT);
|
|
ASSERT_EQ(txInfo.totalAmount, tr.amount);
|
|
|
|
ASSERT_EQ(Bob.pendingBalance(), tr.amount);
|
|
ASSERT_EQ(Bob.actualBalance(), 0);
|
|
}
|