Merge branch 'dapsnet'

Author: Alexander Avramenko

api/include/apihandler.hpp

@@ -436,12 +436,15 @@ public slots:
         const std::string& p_exec_ip, const std::string& p_exec_cmdline)
     : blockchain_(p_blockchain)
     , solver_(solver)
-    , executorTransport_(new ::apache::thrift::transport::TBufferedTransport(
-        ::apache::thrift::stdcxx::make_shared<::apache::thrift::transport::TSocket>(p_exec_ip, p_exec_port)))
+    , socket_(::apache::thrift::stdcxx::make_shared<::apache::thrift::transport::TSocket>(p_exec_ip, p_exec_port))
+    , executorTransport_(new ::apache::thrift::transport::TBufferedTransport(socket_))
     , origExecutor_(
           std::make_unique<executor::ContractExecutorConcurrentClient>(::apache::thrift::stdcxx::make_shared<apache::thrift::protocol::TBinaryProtocol>(executorTransport_))) {
         std::string executorCmdline = p_exec_cmdline;
 
+        socket_->setSendTimeout(kSendTimeout);
+        socket_->setRecvTimeout(kReceiveTimeout);
+
         if (executorCmdline.empty()) {
             cswarning() << "Executor command line args are empty, process would not be created";
             return;
@@ -561,7 +564,10 @@ public slots:
 private:
     const BlockChain& blockchain_;
     const cs::SolverCore& solver_;
+
+    ::apache::thrift::stdcxx::shared_ptr<::apache::thrift::transport::TSocket> socket_;
     ::apache::thrift::stdcxx::shared_ptr<::apache::thrift::transport::TTransport> executorTransport_;
+
     std::unique_ptr<executor::ContractExecutorConcurrentClient> origExecutor_;
     std::unique_ptr<cs::Process> executorProcess_;
 
@@ -577,8 +583,13 @@ public slots:
 
     std::condition_variable cvErrorConnect_;
     std::atomic_bool requestStop_{ false };
+
     const int16_t EXECUTOR_VERSION = 2;
 
+    // timeout in ms
+    const int kSendTimeout = 4000;
+    const int kReceiveTimeout = 4000;
+
     // temporary solution?
     std::mutex callExecutorLock_;
 };

api/src/apihandler.cpp

@@ -273,16 +273,12 @@ api::SealedTransaction APIHandler::convertTransaction(const csdb::Transaction& t
     csdb::Currency currency = transaction.currency();
     csdb::Address address = transaction.source();
     if (address.is_wallet_id()) {
-        BlockChain::WalletData data_to_fetch_pulic_key;
-        s_blockchain.findWalletData(transaction.source().wallet_id(), data_to_fetch_pulic_key);
-        address = csdb::Address::from_public_key(data_to_fetch_pulic_key.address_);
+        address = s_blockchain.getAddressByType(transaction.source(), BlockChain::AddressType::PublicKey);
     }
 
     csdb::Address target = transaction.target();
     if (target.is_wallet_id()) {
-        BlockChain::WalletData data_to_fetch_pulic_key;
-        s_blockchain.findWalletData(transaction.target().wallet_id(), data_to_fetch_pulic_key);
-        target = csdb::Address::from_public_key(data_to_fetch_pulic_key.address_);
+        target = s_blockchain.getAddressByType(transaction.target(), BlockChain::AddressType::PublicKey);
     }
 
     result.id = convert_transaction_id(transaction.id());
@@ -1055,7 +1051,23 @@ bool APIHandler::updateSmartCachesTransaction(csdb::Transaction trxn, cs::Sequen
             }
 
             HashState res;
-            { // signal to end waiting for a transaction
+            res.hash = cs::Zero::hash;
+            std::string newStateStr;
+            if (trxn.user_field_ids().count(cs::trx_uf::new_state::RetVal) > 0) {
+                res.retVal = trxn.user_field(cs::trx_uf::new_state::RetVal).template value<std::string>();
+            }
+
+            general::Variant var;
+            if (!res.retVal.empty()) {
+                std::string tmp = res.retVal;
+                var = deserialize<general::Variant>(std::move(tmp));
+            }
+
+            if (trxn.user_field_ids().count(cs::trx_uf::new_state::Value) > 0) {
+                // new_state value, not hash!
+                newStateStr = trxn.user_field(cs::trx_uf::new_state::Value).template value<std::string>();
+            }
+            else { // signal to end waiting for a transaction
                 auto hashStateInst(lockedReference(this->hashStateSL));
                 (*hashStateInst)[target_pk].updateHash([&](const HashState& oldHash) {
                     auto newHashStr = trxn.user_field(cs::trx_uf::new_state::Hash).template value<std::string>();
@@ -1068,16 +1080,18 @@ bool APIHandler::updateSmartCachesTransaction(csdb::Transaction trxn, cs::Sequen
                     });
             }
 
-            if (res.hash != cs::Zero::hash) { // update tokens
+            if (!newStateStr.empty() || res.hash != cs::Zero::hash) { // update tokens
                 auto caller_pk = s_blockchain.getAddressByType(execTrans.source(), BlockChain::AddressType::PublicKey);
 
                 if (is_smart_deploy(smart))
                     tm.checkNewDeploy(target_pk, caller_pk, smart);
 
-                // state also will be updated in update_smart_state_slot()
-                std::string newState = cs::SmartContracts::get_contract_state(s_blockchain, target_pk);
-                if (!newState.empty())
-                    tm.checkNewState(target_pk, caller_pk, smart, newState);
+                if (newStateStr.empty()) {
+                    newStateStr = cs::SmartContracts::get_contract_state(s_blockchain, target_pk);
+                }
+                if (!newStateStr.empty()) {
+                    tm.checkNewState(target_pk, caller_pk, smart, newStateStr);
+                }
             }
         }
     }
@@ -1960,9 +1974,9 @@ void APIHandler::TokensListGet(api::TokensListResult& _return, int64_t offset, i
 }
 
 //////////Wallets
-typedef std::list<std::pair<const cs::WalletsCache::WalletData::Address*, const cs::WalletsCache::WalletData*>> WCSortedList;
+typedef std::list<std::pair<const cs::PublicKey*, const cs::WalletsCache::WalletData*>> WCSortedList;
 template <typename T>
-void walletStep(const cs::WalletsCache::WalletData::Address* addr, const cs::WalletsCache::WalletData* wd, const uint64_t num,
+void walletStep(const cs::PublicKey* addr, const cs::WalletsCache::WalletData* wd, const uint64_t num,
                 std::function<const T&(const cs::WalletsCache::WalletData&)> getter, std::function<bool(const T&, const T&)> comparator, WCSortedList& lst) {
     assert(num > 0);
 
@@ -1987,7 +2001,7 @@ void iterateOverWallets(std::function<const T&(const cs::WalletsCache::WalletDat
     using Comparer = std::function<bool(const T&, const T&)>;
     Comparer comparator = desc ? Comparer(std::greater<T>()) : Comparer(std::less<T>());
 
-    bc.iterateOverWallets([&lst, num, getter, comparator](const cs::WalletsCache::WalletData::Address& addr, const cs::WalletsCache::WalletData& wd) {
+    bc.iterateOverWallets([&lst, num, getter, comparator](const cs::PublicKey& addr, const cs::WalletsCache::WalletData& wd) {
         if (!addr.empty() && wd.balance_ >= csdb::Amount(0)) {
             walletStep(&addr, &wd, num, getter, comparator, lst);
         }
@@ -2051,7 +2065,7 @@ void APIHandler::TrustedGet(TrustedGetResult& _return, int32_t _page) {
     uint32_t limit = PER_PAGE;
     uint32_t total = 0;
 
-    s_blockchain.iterateOverWriters([&_return, &offset, &limit, &total](const cs::WalletsCache::WalletData::Address& addr, const cs::WalletsCache::TrustedData& wd) {
+    s_blockchain.iterateOverWriters([&_return, &offset, &limit, &total](const cs::PublicKey& addr, const cs::WalletsCache::TrustedData& wd) {
         if (addr.empty()) {
             return true;
         }

api/src/tokens.cpp

@@ -252,8 +252,8 @@ void TokensMaster::updateTokenChaches(const csdb::Address& addr, const std::stri
                 [&retBalance](const std::string& balance) { retBalance = balance; });
 
             if (!std::all_of(retBalance.begin(), retBalance.end(), [](char ch) { return (isdigit(ch) || ch == '.'); })) {
+                csdebug() << "executor returns balance as " << retBalance;
                 retBalance = "0";
-                cserror() << "executor return text balance!";
             }
             return retBalance;
         };

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
@@ -214,7 +215,7 @@ public slots:
     csdb::Pool loadBlock(const cs::Sequence sequence) const;
     csdb::Pool loadBlockMeta(const csdb::PoolHash&, size_t& cnt) const;
     csdb::Transaction loadTransaction(const csdb::TransactionID&) const;
-    void iterateOverWallets(const std::function<bool(const cs::WalletsCache::WalletData::Address&, const cs::WalletsCache::WalletData&)>);
+    void iterateOverWallets(const std::function<bool(const cs::PublicKey&, const cs::WalletsCache::WalletData&)>);
     csdb::Pool getLastBlock() const {
 		return loadBlock(getLastSeq());
     }
@@ -234,11 +235,9 @@ public slots:
     bool findWalletId(const WalletAddress& address, WalletId& id) const;
     // wallet transactions: pools cache + db search
     void getTransactions(Transactions& transactions, csdb::Address address, uint64_t offset, uint64_t limit);
-    // wallets modified by last new block
-    bool getModifiedWallets(Mask& dest) const;
 
 #ifdef MONITOR_NODE
-    void iterateOverWriters(const std::function<bool(const cs::WalletsCache::WalletData::Address&, const cs::WalletsCache::TrustedData&)>);
+    void iterateOverWriters(const std::function<bool(const cs::PublicKey&, const cs::WalletsCache::TrustedData&)>);
     void applyToWallet(const csdb::Address&, const std::function<void(const cs::WalletsCache::WalletData&)>); 
 #endif
     uint32_t getTransactionsCount(const csdb::Address&);
@@ -257,6 +256,10 @@ public slots:
     bool updateContractData(const csdb::Address& abs_addr, const cs::Bytes& data) const;
     bool getContractData(const csdb::Address& abs_addr, cs::Bytes& data) const;
 
+    const cs::WalletsCache::Updater& getCacheUpdater() const {
+        return *(walletsCacheUpdater_.get());
+    }
+
 private:
     void createCachesPath();
     bool findAddrByWalletId(const WalletId id, csdb::Address& addr) const;
@@ -271,9 +274,7 @@ public slots:
     void onReadFromDB(csdb::Pool block, bool* shouldStop);
     bool postInitFromDB();
 
-    template <typename WalletCacheProcessor>
-    bool updateWalletIds(const csdb::Pool& pool, WalletCacheProcessor& proc);
-    bool insertNewWalletId(const csdb::Address& newWallAddress, WalletId newWalletId, cs::WalletsCache::Initer& initer);
+    bool updateWalletIds(const csdb::Pool& pool, cs::WalletsCache::Updater& updater);
     bool insertNewWalletId(const csdb::Address& newWallAddress, WalletId newWalletId, cs::WalletsCache::Updater& updater);
 
     void addNewWalletToPool(const csdb::Address& walletAddress, const csdb::Pool::NewWalletInfo::AddressId& addressId, csdb::Pool::NewWallets& newWallets);

csnode/include/csnode/transactionstail.hpp

@@ -3,6 +3,8 @@
 
 #include "bitheap.hpp"
 
+#include <sstream>
+
 namespace cs {
 class TransactionsTail {
 public: