transaction_pool.hpp

Go to the documentation of this file.

#ifndef KAGOME_TRANSACTION_POOL_HPP
#define KAGOME_TRANSACTION_POOL_HPP

#include <outcome/outcome.hpp>

#include "primitives/block_id.hpp"
#include "primitives/transaction.hpp"
#include "primitives/transaction_validity.hpp"

namespace kagome::transaction_pool {

  using primitives::Transaction;

  class TransactionPool {
   public:
    struct Status;
    struct Limits;

    virtual ~TransactionPool() = default;

    virtual const std::unordered_map<Transaction::Hash,
                                     std::shared_ptr<Transaction>>
        &getPendingTransactions() const = 0;

    virtual outcome::result<Transaction::Hash> submitExtrinsic(
        primitives::TransactionSource source,
        primitives::Extrinsic extrinsic) = 0;

    virtual outcome::result<void> submitOne(Transaction &&tx) = 0;

    virtual outcome::result<Transaction> removeOne(
        const Transaction::Hash &txHash) = 0;

    virtual std::map<Transaction::Hash, std::shared_ptr<Transaction>>
    getReadyTransactions() const = 0;

    virtual outcome::result<std::vector<Transaction>> removeStale(
        const primitives::BlockId &at) = 0;

    virtual Status getStatus() const = 0;

    virtual outcome::result<primitives::Transaction> constructTransaction(
        primitives::TransactionSource source,
        primitives::Extrinsic extrinsic) const = 0;
  };

  struct TransactionPool::Status {
    size_t ready_num;
    size_t waiting_num;
  };

  struct TransactionPool::Limits {
    static constexpr size_t kDefaultMaxReadyNum = 128;
    static constexpr size_t kDefaultCapacity = 512;

    size_t max_ready_num = kDefaultMaxReadyNum;
    size_t capacity = kDefaultCapacity;
  };

}  // namespace kagome::transaction_pool

#endif  // KAGOME_TRANSACTION_POOL_HPP