transaction_manager.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
 
#include "common/event.hpp"
#include "common/thread_pool.hpp"
#include "common/util.hpp"
#include "final_chain/final_chain.hpp"
#include "logger/logging.hpp"
#include "storage/storage.hpp"
#include "transaction/transaction.hpp"
#include "transaction_queue.hpp"
 
namespace taraxa {
 
enum class TransactionStatus { Inserted = 0, InsertedNonProposable, Known, Overflow };
 
struct FullNodeConfig;
class DagBlock;
class DagManager;
 
class TransactionManager : public std::enable_shared_from_this<TransactionManager> {
 public:
  TransactionManager(const FullNodeConfig &conf, std::shared_ptr<DbStorage> db,
                     std::shared_ptr<final_chain::FinalChain> final_chain);
 
  uint64_t estimateTransactions(const SharedTransactions &trxs, PbftPeriod proposal_period);
 
  state_api::ExecutionResult estimateTransactionGas(std::shared_ptr<Transaction> trx, PbftPeriod proposal_period);
 
  std::pair<SharedTransactions, std::vector<uint64_t>> packTrxs(PbftPeriod proposal_period, uint64_t weight_limit);
 
  std::vector<SharedTransactions> getAllPoolTrxs();
 
  void saveTransactionsFromDagBlock(const SharedTransactions &trxs);
 
  std::pair<bool, std::string> insertTransaction(const std::shared_ptr<Transaction> &trx);
 
  void blockFinalized(EthBlockNumber block_number);
 
  TransactionStatus insertValidatedTransaction(std::shared_ptr<Transaction> &&tx, bool insert_non_proposable = true);
 
  bool isTransactionKnown(const trx_hash_t &trx_hash);
 
  size_t getTransactionPoolSize() const;
 
  bool isTransactionPoolFull(size_t percentage = 100) const;
 
  bool nonProposableTransactionsOverTheLimit() const;
 
  size_t getNonfinalizedTrxSize() const;
 
  std::vector<std::shared_ptr<Transaction>> getNonfinalizedTrx(const std::vector<trx_hash_t> &hashes);
 
  std::unordered_set<trx_hash_t> excludeFinalizedTransactions(const std::vector<trx_hash_t> &hashes);
 
  bool verifyTransactionsNotFinalized(const SharedTransactions &trxs);
 
  SharedTransactions getBlockTransactions(const DagBlock &blk, PbftPeriod proposal_period);
 
  SharedTransactions getTransactions(const vec_trx_t &trxs_hashes, PbftPeriod proposal_period);
 
  void updateFinalizedTransactionsStatus(const PeriodData &period_data);
 
  void initializeRecentlyFinalizedTransactions(const PeriodData &period_data);
 
  void removeNonFinalizedTransactions(std::unordered_set<trx_hash_t> &&transactions);
 
  std::shared_mutex &getTransactionsMutex() { return transactions_mutex_; }
 
  std::pair<std::vector<std::shared_ptr<Transaction>>, std::vector<trx_hash_t>> getPoolTransactions(
      const std::vector<trx_hash_t> &trx_to_query) const;
 
  bool transactionsDropped() const;
 
  val_t getMinGasPriceForBlockInclusion() const;
 
  std::shared_ptr<Transaction> getTransaction(const trx_hash_t &hash) const;
  std::shared_ptr<Transaction> getNonFinalizedTransaction(const trx_hash_t &hash) const;
  unsigned long getTransactionCount() const;
  void recoverNonfinalizedTransactions();
  std::pair<bool, std::string> verifyTransaction(const std::shared_ptr<Transaction> &trx) const;
 
 private:
  addr_t getFullNodeAddress() const;
 
 private:
  const FullNodeConfig &kConf;
  // Guards updating transaction status
  // Transactions can be in one of three states:
  // 1. In transactions pool; 2. In non-finalized Dag block 3. Executed
  mutable std::shared_mutex transactions_mutex_;
  TransactionQueue transactions_pool_;
  std::unordered_map<trx_hash_t, std::shared_ptr<Transaction>> nonfinalized_transactions_in_dag_;
  std::unordered_map<trx_hash_t, std::shared_ptr<Transaction>> recently_finalized_transactions_;
  std::unordered_map<PbftPeriod, std::vector<trx_hash_t>> recently_finalized_transactions_per_period_;
  ExpirationCacheMap<trx_hash_t, state_api::ExecutionResult> estimations_cache_;
  uint64_t trx_count_ = 0;
 
  const uint64_t kDagBlockGasLimit;
  const uint64_t kEstimateGasLimit = 200000;
  const uint64_t kRecentlyFinalizedTransactionsMax = 50000;
 
  std::shared_ptr<DbStorage> db_{nullptr};
  std::shared_ptr<final_chain::FinalChain> final_chain_{nullptr};
 
  util::ThreadPool estimation_thread_pool_;
 
  logger::Logger logger_;
 
 public:
  util::Event<TransactionManager, const trx_hash_t &> const transaction_added_{};
};
 
}  // namespace taraxa