TransactionId WalletLegacy::withdrawDeposits(const std::vector<DepositId>& depositIds, uint64_t fee) {
throwIfNotInitialised();
TransactionId txId = 0;
std::unique_ptr<WalletRequest> request;
std::deque<std::unique_ptr<WalletLegacyEvent>> events;
{
std::unique_lock<std::mutex> lock(m_cacheMutex);
request = m_sender->makeWithdrawDepositRequest(txId, events, depositIds, fee);
if (request != nullptr) {
pushBalanceUpdatedEvents(events);
}
}
notifyClients(events);
if (request != nullptr) {
m_asyncContextCounter.addAsyncContext();
request->perform(m_node, std::bind(&WalletLegacy::sendTransactionCallback, this, std::placeholders::_1, std::placeholders::_2));
}
return txId;
}
void WalletLegacy::onTransactionUpdated(ITransfersSubscription* object, const Hash& transactionHash) {
std::deque<std::unique_ptr<WalletLegacyEvent>> events;
TransactionInformation txInfo;
uint64_t amountIn;
uint64_t amountOut;
if (m_transferDetails->getTransactionInformation(transactionHash, txInfo, &amountIn, &amountOut)) {
std::unique_lock<std::mutex> lock(m_cacheMutex);
auto newDepositOuts = m_transferDetails->getTransactionOutputs(transactionHash, ITransfersContainer::IncludeTypeDeposit | ITransfersContainer::IncludeStateAll);
auto spentDeposits = m_transferDetails->getTransactionInputs(transactionHash, ITransfersContainer::IncludeTypeDeposit);
events = m_transactionsCache.onTransactionUpdated(txInfo, static_cast<int64_t>(amountOut)-static_cast<int64_t>(amountIn), newDepositOuts, spentDeposits, m_currency);
auto actualDepositBalanceChangedEvent = getActualDepositBalanceChangedEvent();
auto pendingDepositBalanceChangedEvent = getPendingDepositBalanceChangedEvent();
if (actualDepositBalanceChangedEvent) {
events.push_back(std::move(actualDepositBalanceChangedEvent));
}
if (pendingDepositBalanceChangedEvent) {
events.push_back(std::move(pendingDepositBalanceChangedEvent));
}
}
notifyClients(events);
}
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));
}
}
TransactionId WalletLegacy::deposit(uint32_t term, uint64_t amount, uint64_t fee, uint64_t mixIn) {
throwIfNotInitialised();
TransactionId txId = 0;
std::unique_ptr<WalletRequest> request;
std::deque<std::unique_ptr<WalletLegacyEvent>> events;
{
std::unique_lock<std::mutex> lock(m_cacheMutex);
request = m_sender->makeDepositRequest(txId, events, term, amount, fee, mixIn);
if (request != nullptr) {
pushBalanceUpdatedEvents(events);
}
}
notifyClients(events);
if (request) {
m_asyncContextCounter.addAsyncContext();
request->perform(m_node, std::bind(&WalletLegacy::sendTransactionCallback, this, std::placeholders::_1, std::placeholders::_2));
}
return txId;
}
TransactionId WalletLegacy::sendTransaction(const std::vector<WalletLegacyTransfer>& transfers,
uint64_t fee,
const std::string& extra,
uint64_t mixIn,
uint64_t unlockTimestamp,
const std::vector<TransactionMessage>& messages,
uint64_t ttl) {
TransactionId txId = 0;
std::unique_ptr<WalletRequest> request;
std::deque<std::unique_ptr<WalletLegacyEvent>> events;
throwIfNotInitialised();
{
std::unique_lock<std::mutex> lock(m_cacheMutex);
request = m_sender->makeSendRequest(txId, events, transfers, fee, extra, mixIn, unlockTimestamp, messages, ttl);
}
notifyClients(events);
if (request) {
m_asyncContextCounter.addAsyncContext();
request->perform(m_node, std::bind(&WalletLegacy::sendTransactionCallback, this, std::placeholders::_1, std::placeholders::_2));
}
return txId;
}
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));
}
}
bool AgentConfig::handle()
{
if (!_zm)
{
XLOG_ERROR( "AgentConfig::handle failed, because zkmananager is null!" );
return false;
}
if (_prx == "")
{
XLOG_ERROR( "AgentConfig::handle failed, because _prx is null!") ;
return false;
}
std::vector < std::string > newConfig = update();
if (newConfig.empty())
{
XLOG_ERROR( "AgentConfig::handle can not get agents config from zk!" );
return false;
}
std::vector<std::string>::const_iterator findIt = find(newConfig.begin(), newConfig.end(),
_prx);
if (findIt == newConfig.end())
{
if (subscribe())
{
newConfig.push_back(_prx);
}
else
{
return false;
}
}
setConfig(newConfig);
notifyClients();
return true;
}
void WalletLegacy::onTransactionDeleted(ITransfersSubscription* object, const Hash& transactionHash) {
std::deque<std::unique_ptr<WalletLegacyEvent>> events;
{
std::unique_lock<std::mutex> lock(m_cacheMutex);
events = m_transactionsCache.onTransactionDeleted(transactionHash);
std::unique_ptr<WalletLegacyEvent> actualDepositBalanceUpdated = getActualDepositBalanceChangedEvent();
if (actualDepositBalanceUpdated) {
events.push_back(std::move(actualDepositBalanceUpdated));
}
std::unique_ptr<WalletLegacyEvent> pendingDepositBalanceUpdated = getPendingDepositBalanceChangedEvent();
if (pendingDepositBalanceUpdated) {
events.push_back(std::move(pendingDepositBalanceUpdated));
}
}
notifyClients(events);
}
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 AbstractDynastat::clientNotifier() {
while (running) {
notifyClients();
boost::this_thread::sleep(boost::posix_time::milliseconds(1000 / framerate));
}
}
