chore: improve eth_getLogs

Author: mfrankovi

libraries/core_libs/consensus/include/final_chain/cache.hpp

@@ -121,13 +121,19 @@ class ValueByBlockCache {
     }
   }
 
+  std::optional<Value> getFromCache(uint64_t block_num) const {
+    std::shared_lock lock(mutex_);
+    auto blk_entry = data_by_block_.find(block_num);
+    if (blk_entry != data_by_block_.end()) {
+      return blk_entry->second;
+    }
+    return {};
+  }
+
   Value get(uint64_t block_num) const {
-    {
-      std::shared_lock lock(mutex_);
-      auto blk_entry = data_by_block_.find(block_num);
-      if (blk_entry != data_by_block_.end()) {
-        return blk_entry->second;
-      }
+    auto blk_entry = getFromCache(block_num);
+    if (blk_entry) {
+      return *blk_entry;
     }
 
     auto value = getter_fn_(block_num);

libraries/core_libs/consensus/include/final_chain/final_chain.hpp

@@ -131,7 +131,15 @@ class FinalChain {
   std::optional<TransactionReceipt> transactionReceipt(EthBlockNumber blk_n, uint64_t position,
                                                        std::optional<trx_hash_t> trx_hash = {}) const;
 
-  /**
+  std::shared_ptr<Transaction> transaction(EthBlockNumber blk_n, uint32_t position) const {
+    auto blk_trxs = transactions_cache_.getFromCache(blk_n);
+    if(blk_trxs) {
+      return (*blk_trxs)[position];
+    }
+    return db_->getTransaction(blk_n, position);
+  }
+
+/**
    * @brief Method to get transactions count in block
    * @param n block number
    * @return count of transactions in block

libraries/core_libs/network/rpc/eth/LogFilter.cpp

@@ -126,19 +126,26 @@ void LogFilter::match_one(const ExtendedTransactionLocation& trx_loc, const Tran
 
 std::vector<LocalisedLogEntry> LogFilter::match_all(const final_chain::FinalChain& final_chain) const {
   std::vector<LocalisedLogEntry> ret;
-
   auto action = [&, this](EthBlockNumber blk_n) {
     ExtendedTransactionLocation trx_loc{{{blk_n}, *final_chain.blockHash(blk_n)}};
-    auto hashes = final_chain.transactionHashes(trx_loc.period);
     auto block_receipts = final_chain.blockReceipts(blk_n);
-
-    if (block_receipts && block_receipts->size() == hashes->size()) {
+    if (block_receipts && block_receipts->size()) {
+      std::vector<std::pair<uint64_t, LocalisedLogEntry>> ret_block;
       for (uint32_t i = 0; i < block_receipts->size(); i++) {
-        trx_loc.trx_hash = (*hashes)[i];
-        match_one(trx_loc, (*block_receipts)[i], [&](const auto& lle) { ret.push_back(lle); });
+        match_one(trx_loc, (*block_receipts)[i], [&](const auto& lle) { ret_block.push_back({i, lle}); });
         ++trx_loc.position;
       }
+      if (ret_block.size() > 0) {
+        for (auto& r : ret_block) {
+          auto transaction = final_chain.transaction(trx_loc.period, r.first);
+          if(transaction) {
+            r.second.trx_loc.trx_hash = transaction->getHash();
+            ret.push_back(r.second);
+          }
+        }
+      }
     } else {
+      auto hashes = final_chain.transactionHashes(trx_loc.period);
       for (const auto& hash : *hashes) {
         trx_loc.trx_hash = hash;
         match_one(trx_loc, *final_chain.transactionReceipt(trx_loc.period, trx_loc.position, hash),

libraries/core_libs/storage/include/storage/storage.hpp

@@ -261,6 +261,8 @@ class DbStorage : public std::enable_shared_from_this<DbStorage> {
 
   // Transaction
   std::shared_ptr<Transaction> getTransaction(trx_hash_t const& hash) const;
+  std::shared_ptr<Transaction> getTransaction(PbftPeriod period, uint32_t position) const;
+
   SharedTransactions getAllNonfinalizedTransactions();
   bool transactionInDb(trx_hash_t const& hash);
   bool transactionFinalized(trx_hash_t const& hash);

libraries/core_libs/storage/src/storage.cpp

@@ -850,19 +850,24 @@ std::shared_ptr<Transaction> DbStorage::getTransaction(trx_hash_t const& hash) c
   }
   auto location = getTransactionLocation(hash);
   if (location && !location->is_system) {
-    auto period_data = getPeriodDataRaw(location->period);
-    if (period_data.size() > 0) {
-      auto period_data_rlp = dev::RLP(period_data);
-      auto transaction_data = period_data_rlp[TRANSACTIONS_POS_IN_PERIOD_DATA];
-      return std::make_shared<Transaction>(transaction_data[location->position]);
-    }
+    return getTransaction(location->period, location->position);
   } else {
     // get system trx from a different column
     return getSystemTransaction(hash);
   }
   return nullptr;
 }
 
+std::shared_ptr<Transaction> DbStorage::getTransaction(PbftPeriod period, uint32_t position) const {
+  auto period_data = getPeriodDataRaw(period);
+  if (period_data.size() > 0) {
+    auto period_data_rlp = dev::RLP(period_data);
+    auto transaction_data = period_data_rlp[TRANSACTIONS_POS_IN_PERIOD_DATA];
+    return std::make_shared<Transaction>(transaction_data[position]);
+  }
+  return nullptr;
+}
+
 uint64_t DbStorage::getTransactionCount(PbftPeriod period) const {
   auto period_data = getPeriodDataRaw(period);
   if (period_data.size()) {