Merge branch 'dapsnet' of https://gitlab.com/credits_bc/core/node into dev

Author: Instand

csdb/include/csdb/database.hpp

@@ -47,6 +47,7 @@ class Database {
 
     virtual bool putToTransIndex(const cs::Bytes& key, const cs::Bytes& value) = 0;
     virtual bool getFromTransIndex(const cs::Bytes& key, cs::Bytes* value) = 0;
+    virtual bool removeLastFromTrxIndex(const cs::Bytes& key) = 0;
     virtual void truncateTransIndex() = 0;
 
     virtual bool updateContractData(const cs::Bytes& key, const cs::Bytes& data) = 0;

csdb/include/csdb/database_berkeleydb.hpp

@@ -40,6 +40,7 @@ class DatabaseBerkeleyDB : public Database {
 
     bool putToTransIndex(const cs::Bytes& key, const cs::Bytes& value) override final;
     bool getFromTransIndex(const cs::Bytes& key, cs::Bytes* value) override final;
+    bool removeLastFromTrxIndex(const cs::Bytes& key) override final;
     void truncateTransIndex() override final;
 
     bool updateContractData(const cs::Bytes& key, const cs::Bytes& data) override;

csdb/include/csdb/storage.hpp

@@ -227,6 +227,7 @@ class Storage final {
     // And now for something completely different
     cs::Sequence get_previous_transaction_block(const Address&, cs::Sequence) const;
     void set_previous_transaction_block(const Address&, cs::Sequence currTransBlock, cs::Sequence prevTransBlock);
+    void remove_last_from_trx_index(const Address&, cs::Sequence lastIndexed);
     void truncate_trxs_index();
 
     /**

csdb/src/database_berkeleydb.cpp

@@ -497,6 +497,24 @@ bool DatabaseBerkeleyDB::putToTransIndex(const cs::Bytes &key, const cs::Bytes &
     return true;
 }
 
+bool DatabaseBerkeleyDB::removeLastFromTrxIndex(const cs::Bytes &key) {
+    if (!db_trans_idx_) {
+        set_last_error(NotOpen);
+        return false;
+    }
+
+    Dbt_copy<cs::Bytes> db_key(key);
+
+    int status = db_trans_idx_->del(nullptr, &db_key, 0);
+    if (status != 0) {
+        set_last_error_from_berkeleydb(status);
+        return false;
+    }
+
+    set_last_error();
+    return true;
+}
+
 bool DatabaseBerkeleyDB::getFromTransIndex(const cs::Bytes &key, cs::Bytes *value) {
     if (!db_trans_idx_) {
         set_last_error(NotOpen);

csdb/src/storage.cpp

@@ -871,6 +871,10 @@ void Storage::set_previous_transaction_block(const Address& addr, cs::Sequence c
     d->db->putToTransIndex(key, os.buffer());
 }
 
+void Storage::remove_last_from_trx_index(const Address& addr, cs::Sequence lastIndexed) {
+    d->db->removeLastFromTrxIndex(get_trans_index_key(addr, lastIndexed));
+}
+
 void Storage::truncate_trxs_index() {
     d->db->truncateTransIndex();
 }

csnode/include/csnode/blockchain.hpp

@@ -115,6 +115,7 @@ class BlockChain {
     }
 
     void removeWalletsInPoolFromCache(const csdb::Pool& pool);
+    void removeLastBlockFromTrxIndex(const csdb::Pool&);
     void removeLastBlock();
 
     // updates fees in every transaction

csnode/include/csnode/walletscache.hpp

@@ -4,6 +4,7 @@
 #include <list>
 #include <memory>
 #include <unordered_map>
+#include <vector>
 
 #include <cscrypto/cscrypto.hpp>
 #include <csdb/address.hpp>
@@ -107,6 +108,8 @@ class WalletsCache::Updater {
     void rollbackExceededTimeoutContract(const csdb::Transaction&, const WalletsCache::RefContractCall&, const csdb::Amount& execFee = 0);
     void smartSourceTransactionReleased(const csdb::Transaction& smartSourceTrx, const csdb::Transaction& initTrx);
 
+    void updateLastTransactions(const std::vector<std::pair<PublicKey, csdb::TransactionID>>&);
+
     PublicKey toPublicKey(const csdb::Address&) const;
 
 private:

csnode/src/blockchain.cpp

@@ -444,6 +444,7 @@ void BlockChain::removeLastBlock() {
 	--lastSequence_;
     total_transactions_count_ -= pool.transactions().size();
     removeWalletsInPoolFromCache(pool);
+    removeLastBlockFromTrxIndex(pool);
 
     emit removeBlockEvent(pool.sequence());
 
@@ -461,7 +462,54 @@ csdb::Address BlockChain::getAddressFromKey(const std::string& key) {
         return res;
     }
 }
-
+
+void BlockChain::removeLastBlockFromTrxIndex(const csdb::Pool& pool) {
+    std::set<csdb::Address> uniqueAddresses;
+    std::vector<std::pair<cs::PublicKey, csdb::TransactionID>> updates;
+
+    auto lbd = [&updates, &uniqueAddresses, this](const csdb::Address& addr, cs::Sequence sq) {
+        auto key = getAddressByType(addr, AddressType::PublicKey);
+
+        if (uniqueAddresses.insert(key).second) {
+            auto it = TransactionsIterator(*this, addr);
+            it.next();
+            bool found = false;
+
+            for (; it.isValid(); it.next()) {
+                if (it->id().pool_seq() < sq) {
+                    updates.push_back(std::make_pair(key.public_key(), it->id()));
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                updates.push_back(std::make_pair(key.public_key(),
+                                                 csdb::TransactionID(kWrongSequence, kWrongSequence)));
+            }
+
+            std::lock_guard<decltype(dbLock_)> l(dbLock_);
+            storage_.remove_last_from_trx_index(key, sq);
+        }
+    };
+
+    for (const auto& t : pool.transactions()) {
+        lbd(t.source(), lastIndexedPool);
+        lbd(t.target(), lastIndexedPool);
+    }
+    --lastIndexedPool;
+    updateLastIndFile();
+
+    if (lastNonEmptyBlock_.poolSeq == pool.sequence()) {
+        lastNonEmptyBlock_ = previousNonEmpty_[lastNonEmptyBlock_.poolSeq];
+        previousNonEmpty_.erase(pool.sequence());
+    }
+
+    if (updates.size()) {
+        std::lock_guard l(cacheMutex_);
+        walletsCacheUpdater_->updateLastTransactions(updates);
+    }
+}
+
 void BlockChain::removeWalletsInPoolFromCache(const csdb::Pool& pool) {
     try {
         std::lock_guard lock(cacheMutex_);

csnode/src/walletscache.cpp

@@ -360,6 +360,16 @@ void WalletsCache::Updater::loadTrxForTarget(const csdb::Transaction& tr) {
     wallData.lastTransaction_ = tr.id();
 }
 
+void WalletsCache::Updater::updateLastTransactions(const std::vector<std::pair<PublicKey, csdb::TransactionID>>& updates) {
+    for (const auto& u : updates) {
+        auto it = std::find_if(data_.wallets_.begin(), data_.wallets_.end(), [&u](auto& wall) {
+                               return wall.first == u.first; });
+        if (it != data_.wallets_.end()) {
+            it->second.lastTransaction_ = u.second;
+        }
+    }
+}
+
 void WalletsCache::iterateOverWallets(const std::function<bool(const PublicKey&, const WalletData&)> func) {
     for (const auto& wallet : wallets_) {
         if (!func(wallet.first, wallet.second)) {