trx_id -> dapsnet

Author: Alexander Avramenko

api/include/apihandler.hpp

@@ -607,8 +607,8 @@ class APIHandler : public APIHandlerInterface {
     void PoolListGet(api::PoolListGetResult& _return, const int64_t offset, const int64_t limit) override;
 
     // Get pool info by pool hash. Starts looking from last one (head pool).
-    void PoolInfoGet(api::PoolInfoGetResult& _return, const api::PoolHash& hash, const int64_t index) override;
-    void PoolTransactionsGet(api::PoolTransactionsGetResult& _return, const api::PoolHash& hash, const int64_t offset, const int64_t limit) override;
+    void PoolInfoGet(api::PoolInfoGetResult& _return, const int64_t sequence, const int64_t index) override;
+    void PoolTransactionsGet(api::PoolTransactionsGetResult& _return, const int64_t sequence, const int64_t offset, const int64_t limit) override;
     void StatsGet(api::StatsGetResult& _return) override;
 
     void SmartContractGet(api::SmartContractGetResult& _return, const general::Address& address) override;
@@ -618,7 +618,7 @@ class APIHandler : public APIHandlerInterface {
     void SmartContractAddressesListGet(api::SmartContractAddressesListGetResult& _return, const general::Address& deployer) override;
 
     void GetLastHash(api::PoolHash& _return) override;
-    void PoolListGetStable(api::PoolListGetResult& _return, const api::PoolHash& hash, const int64_t limit) override;
+    void PoolListGetStable(api::PoolListGetResult& _return, const int64_t sequence, const int64_t limit) override;
 
     void WaitForSmartTransaction(api::TransactionId& _return, const general::Address& smart_public) override;
 
@@ -748,7 +748,7 @@ class APIHandler : public APIHandlerInterface {
 
     cs::SpinLockable<std::map<csdb::Address, std::vector<csdb::TransactionID>>> deployed_by_creator;
     //cs::SpinLockable<PendingSmartTransactions> pending_smart_transactions;
-    std::map<csdb::PoolHash, api::Pool> poolCache;
+    cs::SpinLockable < std::map<cs::Sequence, api::Pool> > poolCache;
     std::atomic_flag state_updater_running = ATOMIC_FLAG_INIT;
     std::thread state_updater;
 

api/src/apihandler.cpp

@@ -219,14 +219,14 @@ general::Amount convertAmount(const csdb::Amount& amount) {
 api::TransactionId convert_transaction_id(const csdb::TransactionID& trid) {
     api::TransactionId result_id;
     result_id.index = (uint32_t) trid.index();
-    result_id.poolHash = fromByteArray(trid.pool_hash().to_binary());
+    result_id.poolSeq = trid.pool_seq();
     result_id.__isset.index = true;
-    result_id.__isset.poolHash = true;
+    result_id.__isset.poolSeq = true;
     return result_id;
 }
 
 csdb::TransactionID convert_transaction_id(const api::TransactionId& trid) {
-    return csdb::TransactionID(csdb::PoolHash::from_binary(toByteArray(trid.poolHash)), trid.index);
+    return csdb::TransactionID(trid.poolSeq, trid.index);
 }
 
 bool is_smart(const csdb::Transaction& tr) {
@@ -299,7 +299,7 @@ api::SealedTransaction APIHandler::convertTransaction(const csdb::Transaction& t
 
     result.trxn.timeCreation = transaction.get_time();
 
-    result.trxn.poolNumber = executor_.loadBlockApi(transaction.id().pool_hash()).sequence();
+    result.trxn.poolNumber = executor_.loadBlockApi(transaction.id().pool_seq()).sequence();
 
     if (is_smart(transaction)) {
         using namespace cs::trx_uf;
@@ -412,7 +412,7 @@ api::SealedTransaction APIHandler::convertTransaction(const csdb::Transaction& t
     if (is_smart(transaction)) {
         auto opers = lockedReference(this->smart_operations);
         auto state_id = (*opers)[transaction.id()].stateTransaction;
-        if (!state_id.pool_hash().is_empty()) {
+        if (state_id.is_valid()) {
             stateTrx = executor_.loadTransactionApi(state_id);
         }
     }
@@ -423,7 +423,7 @@ api::SealedTransaction APIHandler::convertTransaction(const csdb::Transaction& t
         return result;
 
     // 2) fill ExtraFee for state transaction
-    auto pool = executor_.loadBlockApi(stateTrx.id().pool_hash());
+    auto pool = executor_.loadBlockApi(stateTrx.id().pool_seq());
     auto transactions = pool.transactions();
     ExtraFee extraFee;
     extraFee.transactionId = convert_transaction_id(stateTrx.id());
@@ -522,8 +522,7 @@ std::vector<api::SealedTransaction> APIHandler::extractTransactions(const csdb::
 }
 
 void APIHandler::TransactionGet(TransactionGetResult& _return, const TransactionId& transactionId) {
-    const csdb::PoolHash poolhash = csdb::PoolHash::from_binary(toByteArray(transactionId.poolHash));
-    const csdb::TransactionID tmpTransactionId = csdb::TransactionID(poolhash, (transactionId.index));
+    const csdb::TransactionID tmpTransactionId = csdb::TransactionID(transactionId.poolSeq, (transactionId.index));
     csdb::Transaction transaction = executor_.loadTransactionApi(tmpTransactionId);
     _return.found = transaction.is_valid();
     if (_return.found)
@@ -592,7 +591,7 @@ api::SmartContract APIHandler::fetch_smart_body(const csdb::Transaction& tr) {
 	if (tr.user_field(0).is_valid())
 		res.transactionsCount = s_blockchain.getTransactionsCount(tr.target());
 
-    auto pool = executor_.loadBlockApi(tr.id().pool_hash());
+    auto pool = executor_.loadBlockApi(tr.id().pool_seq());
     res.createTime = pool.get_time();
 
     return res;
@@ -846,38 +845,25 @@ void APIHandler::TransactionFlow(api::TransactionFlowResult& _return, const Tran
 }
 
 void APIHandler::PoolListGet(api::PoolListGetResult& _return, const int64_t offset, const int64_t const_limit) {
-    if (!validatePagination(_return, *this, offset, const_limit)) {
-        return;
-    }
+    cs::Sequence limit = limitPage(const_limit);
 
     uint64_t sequence = s_blockchain.getLastSeq();
     if ((uint64_t)offset > sequence) {
         return;
     }
 
-    _return.pools.reserve(const_limit);
+    _return.pools.reserve(limit);
 
-    csdb::PoolHash hash;
-    try {
-        hash = s_blockchain.getHashBySequence(sequence - offset);
-    }
-    catch (...) {
-        return;
-    }
-    if (hash.is_empty()) {
-        return;
-    }
-    PoolListGetStable(_return, fromByteArray(hash.to_binary()), const_limit);
+    PoolListGetStable(_return, sequence - offset, limit);
     _return.count = uint32_t(sequence + 1);
 }
 
-void APIHandler::PoolTransactionsGet(PoolTransactionsGetResult& _return, const PoolHash& hash, const int64_t offset, const int64_t const_limit) {
+void APIHandler::PoolTransactionsGet(PoolTransactionsGetResult& _return, const int64_t sequence, const int64_t offset, const int64_t const_limit) {
     //if (!validatePagination(_return, *this, offset, const_limit)) {
     //    return;
     //}
     auto limit = limitPage(const_limit);
-    const csdb::PoolHash poolHash = csdb::PoolHash::from_binary(toByteArray(hash));
-    csdb::Pool pool = executor_.loadBlockApi(poolHash);
+    csdb::Pool pool = executor_.loadBlockApi(cs::Sequence(sequence));
 
     if (pool.is_valid()) {
         _return.transactions = extractTransactions(pool, limit, offset);
@@ -886,14 +872,13 @@ void APIHandler::PoolTransactionsGet(PoolTransactionsGetResult& _return, const P
     SetResponseStatus(_return.status, APIRequestStatusType::SUCCESS);
 }
 
-void APIHandler::PoolInfoGet(PoolInfoGetResult& _return, const PoolHash& hash, const int64_t index) {
+void APIHandler::PoolInfoGet(PoolInfoGetResult& _return, const int64_t sequence, const int64_t index) {
     csunused(index);
-    const csdb::PoolHash poolHash = csdb::PoolHash::from_binary(toByteArray(hash));
-    csdb::Pool pool = executor_.loadBlockApi(poolHash);
+    csdb::Pool pool = executor_.loadBlockApi(cs::Sequence(sequence));
     _return.isFound = pool.is_valid();
 
     if (_return.isFound) {
-        _return.pool = convertPool(poolHash);
+        _return.pool = convertPool(pool);
     }
 
     SetResponseStatus(_return.status, APIRequestStatusType::SUCCESS);
@@ -972,7 +957,7 @@ void APIHandler::collect_all_stats_slot(const csdb::Pool& pool) {
         periodStats.transactionsCount += (uint32_t)transactionsCount;
 
         for (size_t i = 0; i < transactionsCount; ++i) {
-            const auto& transaction = pool.transaction(csdb::TransactionID(pool.hash(), i));
+            const auto& transaction = pool.transaction(csdb::TransactionID(pool.sequence(), i));
 
 #ifdef MONITOR_NODE
             if (is_smart(transaction) || is_smart_state(transaction))
@@ -1007,7 +992,7 @@ void APIHandler::collect_all_stats_slot(const csdb::Pool& pool) {
             periodStats.transactionsCount += (uint32_t)transactionsCount;
 
             for (size_t i = 0; i < transactionsCount; ++i) {
-                const auto& transaction = pool.transaction(csdb::TransactionID(pool.hash(), i));
+                const auto& transaction = pool.transaction(csdb::TransactionID(pool.sequence(), i));
 
                 if (transaction.source() == s_blockchain.getGenesisAddress())
                     continue;
@@ -1040,7 +1025,7 @@ bool APIHandler::updateSmartCachesTransaction(csdb::Transaction trxn, cs::Sequen
 
     if (is_smart_state(trxn)) {
         cs::SmartContractRef scr(trxn.user_field(cs::trx_uf::new_state::RefStart));
-        csdb::TransactionID trId(scr.hash, scr.transaction);
+        csdb::TransactionID trId(scr.sequence, scr.transaction);
         const auto execTrans = solver.smart_contracts().get_contract_call(trxn);
 
         if ((execTrans.is_valid() && is_smart(execTrans)) ||
@@ -1183,37 +1168,40 @@ void APIHandler::GetLastHash(api::PoolHash& _return) {
     return;
 }
 
-void APIHandler::PoolListGetStable(api::PoolListGetResult& _return, const api::PoolHash& api_hash, const int64_t const_limit) {
-    auto hash = csdb::PoolHash::from_binary(toByteArray(api_hash));
+void APIHandler::PoolListGetStable(api::PoolListGetResult& _return, const int64_t sequence, const int64_t const_limit) {
     auto limit = limitPage(const_limit);
-
+    cs::Sequence seq = cs::Sequence(sequence);
+    if (seq < 0) {
+        return;
+    }
+    csmeta(csdebug) << "sequence " << seq << ", limit " << limit;
     bool limSet = false;
 
-    while (limit && !hash.is_empty()) {
-        auto cch = poolCache.find(hash);
-
-        if (cch == poolCache.end()) {
-            auto pool = executor_.loadBlockApi(hash);
-            api::Pool apiPool = convertPool(pool);
-            _return.pools.push_back(apiPool);
-            poolCache.insert(cch, std::make_pair(hash, apiPool));
-            hash = pool.previous_hash();
-
-            if (!limSet) {
-                _return.count = uint32_t(pool.sequence() + 1);
-                limSet = true;
+    while (limit) {
+        auto lockedPoolCache = lockedReference(this->poolCache);
+        auto cch = lockedPoolCache->find(seq);
+
+        if (cch == lockedPoolCache->end()) {
+            auto pool = executor_.loadBlockApi(seq);
+            if (pool.is_valid()) {
+                api::Pool apiPool = convertPool(pool);
+                _return.pools.push_back(apiPool);
+                lockedPoolCache->insert(cch, std::make_pair(seq, apiPool));
+                if (!limSet) {
+                    _return.count = uint32_t(seq + 1);
+                    limSet = true;
+                }
             }
         }
         else {
             _return.pools.push_back(cch->second);
-            hash = csdb::PoolHash::from_binary(toByteArray(cch->second.prevHash));
-
             if (!limSet) {
                 _return.count = uint32_t(cch->second.poolNumber + 1);
                 limSet = true;
             }
         }
 
+        --seq;
         --limit;
     }
 }
@@ -1390,7 +1378,7 @@ void addTokenResult(api::TokenTransfersResult& _return, const csdb::Address& tok
     transfer.amount = TokensMaster::getAmount(smart);
     transfer.initiator = fromByteArray(handler.getAddressByType(tr.source(), BlockChain::AddressType::PublicKey).public_key());
 
-    transfer.transaction.poolHash = fromByteArray(tr.id().pool_hash().to_binary());
+    transfer.transaction.poolSeq = tr.id().pool_seq();
     transfer.transaction.index = (uint32_t) tr.id().index();
     transfer.time = atoll(pool.user_field(0).value<std::string>().c_str());
     _return.transfers.push_back(transfer);
@@ -1400,7 +1388,7 @@ void addTokenResult(api::TokenTransactionsResult& _return, const csdb::Address&
                     const api::SmartContractInvocation& smart, const std::pair<csdb::Address, csdb::Address>&, BlockChain& handler) {
     api::TokenTransaction trans;
     trans.token = fromByteArray(token.public_key());
-    trans.transaction.poolHash = fromByteArray(tr.id().pool_hash().to_binary());
+    trans.transaction.poolSeq = tr.id().pool_seq();
     trans.transaction.index = (uint32_t) tr.id().index();
     trans.time = atoll(pool.user_field(0).value<std::string>().c_str());
     trans.initiator = fromByteArray(handler.getAddressByType(tr.source(), BlockChain::AddressType::PublicKey).public_key());
@@ -1491,7 +1479,7 @@ void APIHandler::iterateOverTokenTransactions(const csdb::Address& addr, const s
         if (is_smart_state(*trIt)) {
             cs::SmartContractRef smart_ref;
             smart_ref.from_user_field(trIt->user_field(cs::trx_uf::new_state::RefStart));
-            l_id.emplace_back(csdb::TransactionID(smart_ref.hash, smart_ref.transaction));
+            l_id.emplace_back(csdb::TransactionID(smart_ref.sequence, smart_ref.transaction));
         }
         else if (is_smart(*trIt)) {
             auto it = std::find(l_id.begin(), l_id.end(), trIt->id());
@@ -1655,8 +1643,7 @@ void APIHandler::TokenTransfersGet(api::TokenTransfersResult& _return, const gen
 }
 
 void APIHandler::TokenTransferGet(api::TokenTransfersResult& _return, const general::Address& token, const TransactionId& id) {
-    const csdb::PoolHash poolhash = csdb::PoolHash::from_binary(toByteArray(id.poolHash));
-    const csdb::TransactionID trxn_id = csdb::TransactionID(poolhash, id.index);
+    const csdb::TransactionID trxn_id = csdb::TransactionID(id.poolSeq, id.index);
     const csdb::Transaction trxn = executor_.loadTransactionApi(trxn_id);
     const csdb::Address addr = BlockChain::getAddressFromKey(token);
 
@@ -1673,7 +1660,7 @@ void APIHandler::TokenTransferGet(api::TokenTransfersResult& _return, const gene
         return;
     }
 
-    const auto pool = executor_.loadBlockApi(trxn.id().pool_hash());
+    const auto pool = executor_.loadBlockApi(trxn.id().pool_seq());
     const auto smart = fetch_smart(trxn);
     const auto addr_pk = s_blockchain.getAddressByType(trxn.source(), BlockChain::AddressType::PublicKey);
     const auto addrPair = TokensMaster::getTransferData(addr_pk, smart.method, smart.params);
@@ -1723,24 +1710,23 @@ void APIHandler::TokenTransfersListGet(api::TokenTransfersResult& _return, int64
     }
 
     uint64_t totalTransfers = 0;
-    std::multimap<csdb::PoolHash, csdb::Address> tokenTransPools;
+    std::multimap<cs::Sequence, csdb::Address> tokenTransPools;
 
     tm.loadTokenInfo({}, [&totalTransfers, &tokenTransPools, this](const TokensMap& tm, const HoldersMap&) {
         for (auto& t : tm) {
             totalTransfers += t.second.transfersCount;
-            tokenTransPools.insert(std::make_pair(s_blockchain.getLastTransaction(t.first).pool_hash(), t.first));
+            tokenTransPools.insert(std::make_pair(s_blockchain.getLastTransaction(t.first).pool_seq(), t.first));
         }
     }, false);
 
     _return.count = uint32_t(totalTransfers);
 
     std::vector<csdb::Address> tokenAddrs;
-
-    csdb::PoolHash pooh = s_blockchain.getLastNonEmptyBlock().first;
-    while (limit && !pooh.is_empty() && tokenTransPools.size()) {
-        auto it = tokenTransPools.find(pooh);
+    cs::Sequence seq = s_blockchain.getLastNonEmptyBlock().first;
+    while (limit && seq != cs::kWrongSequence && tokenTransPools.size()) {
+        auto it = tokenTransPools.find(seq);
         if (it != tokenTransPools.end()) {
-            auto pool = executor_.loadBlockApi(pooh);
+            auto pool = executor_.loadBlockApi(seq);
 
             for (auto& t : pool.transactions()) {
                 if (!is_smart(t)) {
@@ -1763,19 +1749,19 @@ void APIHandler::TokenTransfersListGet(api::TokenTransfersResult& _return, int64
             }
 
             do {
-                const auto lPh = s_blockchain.getPreviousPoolHash(it->second, it->first);
+                const auto lPs = s_blockchain.getPreviousPoolSeq(it->second, it->first);
                 const auto lAddr = it->second;
 
                 tokenTransPools.erase(it);
-                if (!lPh.is_empty()) {
-                    tokenTransPools.insert(std::make_pair(lPh, lAddr));
+                if (lPs != cs::kWrongSequence) {
+                    tokenTransPools.insert(std::make_pair(lPs, lAddr));
                 }
 
-                it = tokenTransPools.find(pooh);
+                it = tokenTransPools.find(seq);
             } while (it != tokenTransPools.end());
         }
 
-        pooh = s_blockchain.getPreviousNonEmptyBlock(pooh).first;
+        seq = s_blockchain.getPreviousNonEmptyBlock(seq).first;
     }
 
     tm.loadTokenInfo(tokenAddrs, [&_return](const TokensMap& tm, const HoldersMap&) {

api/src/csstats.cpp

@@ -46,7 +46,7 @@ StatsPerPeriod csstats::collectStats(const Periods& periods) {
             periodStats.transactionsCount += static_cast<uint32_t>(transactionsCount);
 
             for (std::size_t i = 0; i < transactionsCount; ++i) {
-                const auto& transaction = pool.transaction(csdb::TransactionID(pool.hash(), i));
+                const auto& transaction = pool.transaction(csdb::TransactionID(pool.sequence(), i));
 #ifdef MONITOR_NODE
                 if (is_smart(transaction) || is_smart_state(transaction))
                     ++periodStats.transactionsSmartCount;

csdb/include/csdb/storage.hpp

@@ -225,8 +225,8 @@ class Storage final {
     Transaction get_last_by_target(Address target) const noexcept;
 
     // And now for something completely different
-    PoolHash get_previous_transaction_block(const Address&, const PoolHash&) const;
-    void set_previous_transaction_block(const Address&, const PoolHash& currTransBlock, const PoolHash& prevTransBlock);
+    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 truncate_trxs_index();
 
     /**
@@ -268,7 +268,7 @@ class Storage final {
      * \используется для входного параметра addr в виде id кошелька
      */
     bool get_from_blockchain(const Address& addr /*input*/, int64_t innerId /*input*/,
-                             const PoolHash& lastTrxPh, Transaction& trx /*output*/) const;
+                             cs::Sequence lastTrxPs, Transaction& trx /*output*/) const;
 
     /**
      * Gets contract data from storage.
@@ -314,7 +314,7 @@ public signals:
     const ReadBlockSignal& readBlockEvent() const;
 
 private:
-  static cs::Bytes get_trans_index_key(const Address&, const PoolHash&);
+  static cs::Bytes get_trans_index_key(const Address&, cs::Sequence);
   Pool pool_load_internal(const PoolHash& hash, const bool metaOnly, size_t& trxCnt) const;
 
   ::std::shared_ptr<priv> d;