transaction_queue.hpp

Go to the documentation of this file.

#pragma once
 
#include "common/constants.hpp"
#include "common/util.hpp"
#include "transaction/transaction.hpp"
 
namespace taraxa {
 
enum class TransactionStatus;
namespace final_chain {
class FinalChain;
}
class TransactionQueue {
 public:
  TransactionQueue(std::shared_ptr<final_chain::FinalChain> final_chain, size_t max_size = kMinTransactionPoolSize);
 
  TransactionStatus insert(std::shared_ptr<Transaction>&& transaction, bool proposable, uint64_t last_block_number = 0);
 
  bool erase(const SharedTransaction& transaction);
 
  std::shared_ptr<Transaction> get(const trx_hash_t& hash) const;
 
  std::vector<std::shared_ptr<Transaction>> getOrderedTransactions(uint64_t count) const;
 
  std::vector<SharedTransactions> getAllTransactions() const;
 
  bool contains(const trx_hash_t& hash) const;
 
  size_t size() const;
 
  void blockFinalized(uint64_t block_number);
 
  void purge();
 
  void markTransactionKnown(const trx_hash_t& trx_hash);
 
  bool isTransactionKnown(const trx_hash_t& trx_hash) const;
 
  bool transactionsDropped() const {
    return std::chrono::system_clock::now() - transaction_overflow_time_ < kTransactionOverflowTimeLimit;
  }
 
  bool nonProposableTransactionsOverTheLimit() const;
 
  val_t getMinGasPriceForBlockInclusion(uint64_t limit) const;
 
 private:
  void addTransaction(const SharedTransaction& transaction, bool proposable, uint64_t last_block_number = 0);
 
  bool removeTransaction(const SharedTransaction& transaction, bool proposable);
 
  std::unordered_map<taraxa::trx_hash_t, std::pair<uint64_t, taraxa::SharedTransaction>>::iterator removeTransaction(
      std::unordered_map<taraxa::trx_hash_t, std::pair<uint64_t, taraxa::SharedTransaction>>::iterator transaction);
 
  // Transactions in the queue per account ordered by nonce
  std::unordered_map<addr_t, std::map<val_t, std::shared_ptr<Transaction>>> account_nonce_transactions_;
 
  // Transactions in the queue per trx hash
  std::unordered_map<trx_hash_t, std::shared_ptr<Transaction>> queue_transactions_;
 
  // Amount of gas per gas prices in queue
  std::map<val_t, uint64_t, std::greater<val_t>> queue_transactions_gas_prices_;
 
  // Low nonce and insufficient balance transactions which should not be included in proposed dag blocks but it is
  // possible because of dag reordering that some dag block might arrive requiring these transactions.
  std::unordered_map<trx_hash_t, std::pair<uint64_t, std::shared_ptr<Transaction>>> non_proposable_transactions_;
 
  ExpirationCache<trx_hash_t> known_txs_;
 
  // Last time transactions were dropped due to queue reaching max size
  std::chrono::system_clock::time_point transaction_overflow_time_;
 
  // Size of data for transactions in pool
  size_t data_size_ = 0;
 
  // If transactions are dropped within last kTransactionOverflowTimeLimit seconds, dag blocks with missing transactions
  // will not be treated as malicious
  const std::chrono::seconds kTransactionOverflowTimeLimit{600};
 
  // Limit when non proposable transactions expire
  const size_t kNonProposableTransactionsPeriodExpiryLimit = 10;
 
  // Maximum number of non proposable transactions in percentage of kMaxSize
  const size_t kNonProposableTransactionsLimitPercentage = 20;
 
  // Maximum number of single account transactions in percentage of kMaxSize
  const size_t kSingleAccountTransactionsLimitPercentage = 5;
 
  // Maximum number of non proposable transactions
  const size_t kNonProposableTransactionsMaxSize;
 
  // Maximum size of transactions pool
  const size_t kMaxSize;
 
  // Maximum data size of transactions pool
  const size_t kMaxDataSize;
 
  // Maximum size of single account transactions
  const size_t kMaxSingleAccountTransactionsSize;
 
  std::shared_ptr<final_chain::FinalChain> final_chain_;
};
 
}  // namespace taraxa