void WalletLegacy::sendTransactionCallback(WalletRequest::Callback callback, std::error_code ec) {
ContextCounterHolder counterHolder(m_asyncContextCounter);
std::deque<std::unique_ptr<WalletLegacyEvent> > events;
std::unique_ptr<WalletRequest> nextRequest;
{
std::unique_lock<std::mutex> lock(m_cacheMutex);
callback(events, nextRequest, ec);
auto actualDepositBalanceUpdated = getActualDepositBalanceChangedEvent();
if (actualDepositBalanceUpdated) {
events.push_back(std::move(actualDepositBalanceUpdated));
}
auto pendingDepositBalanceUpdated = getPendingDepositBalanceChangedEvent();
if (pendingDepositBalanceUpdated) {
events.push_back(std::move(pendingDepositBalanceUpdated));
}
}
notifyClients(events);
if (nextRequest) {
m_asyncContextCounter.addAsyncContext();
nextRequest->perform(m_node, std::bind(&WalletLegacy::synchronizationCallback, this, std::placeholders::_1, std::placeholders::_2));
}
}
void WalletLegacy::doLoad(std::istream& source) {
ContextCounterHolder counterHolder(m_asyncContextCounter);
try {
std::unique_lock<std::mutex> lock(m_cacheMutex);
std::string cache;
WalletLegacySerializer serializer(m_account, m_transactionsCache);
serializer.deserialize(source, m_password, cache);
initSync();
try {
if (!cache.empty()) {
std::stringstream stream(cache);
m_transfersSync.load(stream);
}
} catch (const std::exception&) {
// ignore cache loading errors
}
} catch (std::system_error& e) {
runAtomic(m_cacheMutex, [this] () {this->m_state = WalletLegacy::NOT_INITIALIZED;} );
m_observerManager.notify(&IWalletLegacyObserver::initCompleted, e.code());
return;
} catch (std::exception&) {
runAtomic(m_cacheMutex, [this] () {this->m_state = WalletLegacy::NOT_INITIALIZED;} );
m_observerManager.notify(&IWalletLegacyObserver::initCompleted, make_error_code(CryptoNote::error::INTERNAL_WALLET_ERROR));
return;
}
m_observerManager.notify(&IWalletLegacyObserver::initCompleted, std::error_code());
}
void WalletLegacy::doSave(std::ostream& destination, bool saveDetailed, bool saveCache) {
ContextCounterHolder counterHolder(m_asyncContextCounter);
try {
m_blockchainSync.stop();
std::unique_lock<std::mutex> lock(m_cacheMutex);
WalletLegacySerializer serializer(m_account, m_transactionsCache);
std::string cache;
if (saveCache) {
std::stringstream stream;
m_transfersSync.save(stream);
cache = stream.str();
}
serializer.serialize(destination, m_password, saveDetailed, cache);
m_state = INITIALIZED;
m_blockchainSync.start(); //XXX: start can throw. what to do in this case?
}
catch (std::system_error& e) {
runAtomic(m_cacheMutex, [this] () {this->m_state = WalletLegacy::INITIALIZED;} );
m_observerManager.notify(&IWalletLegacyObserver::saveCompleted, e.code());
return;
}
catch (std::exception&) {
runAtomic(m_cacheMutex, [this] () {this->m_state = WalletLegacy::INITIALIZED;} );
m_observerManager.notify(&IWalletLegacyObserver::saveCompleted, make_error_code(CryptoNote::error::INTERNAL_WALLET_ERROR));
return;
}
m_observerManager.notify(&IWalletLegacyObserver::saveCompleted, std::error_code());
}
void INodeTrivialRefreshStub::doGetRandomOutsByAmounts(std::vector<uint64_t> amounts, uint64_t outsCount, std::vector<cryptonote::COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount>& result, const Callback& callback)
{
ContextCounterHolder counterHolder(m_asyncCounter);
std::unique_lock<std::mutex> lock(m_multiWalletLock);
for (uint64_t amount: amounts)
{
cryptonote::COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount out;
out.amount = amount;
for (uint64_t i = 0; i < outsCount; ++i)
{
crypto::public_key key;
crypto::secret_key sk;
generate_keys(key, sk);
cryptonote::COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::out_entry e;
e.global_amount_index = i;
e.out_key = key;
out.outs.push_back(e);
}
}
callback(std::error_code());
}
void INodeTrivialRefreshStub::doGetPoolSymmetricDifference(std::vector<crypto::hash>& known_pool_tx_ids, crypto::hash known_block_id, bool& is_bc_actual,
std::vector<cryptonote::Transaction>& new_txs, std::vector<crypto::hash>& deleted_tx_ids, const Callback& callback)
{
ContextCounterHolder counterHolder(m_asyncCounter);
std::unique_lock<std::mutex> lock(m_multiWalletLock);
m_blockchainGenerator.getPoolSymmetricDifference(std::move(known_pool_tx_ids), known_block_id, is_bc_actual, new_txs, deleted_tx_ids);
callback(std::error_code());
}
void INodeTrivialRefreshStub::doGetNewBlocks(std::list<crypto::hash> knownBlockIds, std::list<cryptonote::block_complete_entry>& newBlocks, uint64_t& startHeight, const Callback& callback)
{
ContextCounterHolder counterHolder(m_asyncCounter);
std::unique_lock<std::mutex> lock(m_multiWalletLock);
auto& blockchain = m_blockchainGenerator.getBlockchain();
std::vector<cryptonote::Block>::iterator start = blockchain.end();
for (const auto& id : knownBlockIds) {
start = std::find_if(blockchain.begin(), blockchain.end(),
[&id](cryptonote::Block& block) { return get_block_hash(block) == id; });
if (start != blockchain.end())
break;
}
if (start == blockchain.end()) {
callback(std::error_code());
return;
}
m_lastHeight = std::distance(blockchain.begin(), start);
startHeight = m_lastHeight;
for (; m_lastHeight < blockchain.size(); ++m_lastHeight)
{
cryptonote::block_complete_entry e;
e.block = cryptonote::t_serializable_object_to_blob(blockchain[m_lastHeight]);
for (auto hash : blockchain[m_lastHeight].txHashes)
{
cryptonote::Transaction tx;
if (!m_blockchainGenerator.getTransactionByHash(hash, tx))
continue;
e.txs.push_back(t_serializable_object_to_blob(tx));
}
newBlocks.push_back(e);
if (newBlocks.size() >= m_getMaxBlocks) {
break;
}
}
m_lastHeight = startHeight + newBlocks.size();
// m_lastHeight = startHeight + blockchain.size() - 1;
callback(std::error_code());
}
void INodeTrivialRefreshStub::doGetTransactionOutsGlobalIndices(const crypto::hash& transactionHash, std::vector<uint64_t>& outsGlobalIndices, const Callback& callback)
{
ContextCounterHolder counterHolder(m_asyncCounter);
std::unique_lock<std::mutex> lock(m_multiWalletLock);
cryptonote::Transaction tx;
if (m_blockchainGenerator.getTransactionByHash(transactionHash, tx)) {
outsGlobalIndices.resize(tx.vout.size());
} else {
outsGlobalIndices.resize(20); //random
}
callback(std::error_code());
}
void Wallet::doSave(std::ostream& destination, bool saveDetailed, bool saveCache) {
ContextCounterHolder counterHolder(m_asyncContextCounter);
try {
//TODO: exception safety: leave destination stream empty in case of errors
boost::archive::binary_oarchive ar(destination);
std::stringstream original;
std::unique_lock<std::mutex> lock(m_cacheMutex);
boost::archive::binary_oarchive archive(original);
archive << m_account;
const BlockchainContainer& blockchain = saveCache ? m_blockchain : BlockchainContainer();
archive << blockchain;
m_transferDetails.save(archive, saveCache);
m_unconfirmedTransactions.save(archive, saveCache);
m_transactionsCache.save(archive, saveDetailed, saveCache);
std::string plain = original.str();
std::string cipher;
crypto::chacha8_iv iv = encrypt(plain, cipher);
std::string chacha_str;
::serialization::dump_binary(iv, chacha_str);
ar << chacha_str;
ar << cipher;
m_state = INITIALIZED;
}
catch (std::system_error& e) {
runAtomic(m_cacheMutex, [this] () {this->m_state = Wallet::INITIALIZED;} );
m_observerManager.notify(&IWalletObserver::saveCompleted, e.code());
return;
}
catch (std::exception&) {
runAtomic(m_cacheMutex, [this] () {this->m_state = Wallet::INITIALIZED;} );
m_observerManager.notify(&IWalletObserver::saveCompleted, make_error_code(cryptonote::error::INTERNAL_WALLET_ERROR));
return;
}
m_observerManager.notify(&IWalletObserver::saveCompleted, std::error_code());
}
void WalletLegacy::synchronizationCallback(WalletRequest::Callback callback, std::error_code ec) {
ContextCounterHolder counterHolder(m_asyncContextCounter);
std::deque<std::unique_ptr<WalletLegacyEvent>> events;
std::unique_ptr<WalletRequest> nextRequest;
{
std::unique_lock<std::mutex> lock(m_cacheMutex);
callback(events, nextRequest, ec);
}
notifyClients(events);
if (nextRequest) {
m_asyncContextCounter.addAsyncContext();
nextRequest->perform(m_node, std::bind(&WalletLegacy::synchronizationCallback, this, std::placeholders::_1, std::placeholders::_2));
}
}
void Wallet::synchronizationCallback(WalletRequest::Callback callback, std::error_code ec) {
ContextCounterHolder counterHolder(m_asyncContextCounter);
std::deque<std::shared_ptr<WalletEvent> > events;
boost::optional<std::shared_ptr<WalletRequest> > nextRequest;
{
std::unique_lock<std::mutex> lock(m_cacheMutex);
callback(events, nextRequest, ec);
if (!nextRequest)
m_isSynchronizing = false;
}
notifyClients(events);
if (nextRequest) {
m_asyncContextCounter.addAsyncContext();
(*nextRequest)->perform(m_node, std::bind(&Wallet::synchronizationCallback, this, std::placeholders::_1, std::placeholders::_2));
}
}
void INodeTrivialRefreshStub::doRelayTransaction(const cryptonote::Transaction& transaction, const Callback& callback)
{
ContextCounterHolder counterHolder(m_asyncCounter);
std::unique_lock<std::mutex> lock(m_multiWalletLock);
if (m_nextTxError)
{
m_nextTxError = false;
callback(make_error_code(cryptonote::error::INTERNAL_WALLET_ERROR));
return;
}
if (m_nextTxToPool) {
m_nextTxToPool = false;
m_blockchainGenerator.putTxToPool(transaction);
callback(std::error_code());
return;
}
m_blockchainGenerator.addTxToBlockchain(transaction);
callback(std::error_code());
}
