transaction_validity.hpp

Go to the documentation of this file.

#ifndef KAGOME_CORE_PRIMITIVES_TRANSACTION_VALIDITY_HPP
#define KAGOME_CORE_PRIMITIVES_TRANSACTION_VALIDITY_HPP

#include <cstdint>
#include <vector>

#include <boost/variant.hpp>
#include <outcome/outcome.hpp>

#include "primitives/transaction.hpp"
#include "scale/tie.hpp"

namespace kagome::primitives {

  enum class TransactionSource : uint8_t {
    InBlock,

    Local,

    External,
  };

  struct ValidTransaction {
    SCALE_TIE(5);

    Transaction::Priority priority{};

    std::vector<Transaction::Tag>
    requires;

    std::vector<Transaction::Tag> provides;

    Transaction::Longevity longevity{};

    bool propagate{};
  };

  enum class InvalidTransaction : uint8_t {
    Call = 1,
    Payment,
    Future,
    Stale,
    BadProof,
    AncientBirthBlock,
    ExhaustsResources,
    Custom,
    BadMandatory,
    MandatoryDispatch,
  };

  template <class Stream,
            typename = std::enable_if_t<Stream::is_encoder_stream>>
  Stream &operator<<(Stream &s, const InvalidTransaction &v) {
    // -1 is needed for compatibility with Rust; indices of error codes start
    // from 0 there, while in kagome they must start from 1 because of
    // std::error_code policy
    return s << static_cast<uint8_t>(v) - 1;
  }

  template <class Stream,
            typename = std::enable_if_t<Stream::is_decoder_stream>>
  Stream &operator>>(Stream &s, InvalidTransaction &v) {
    uint8_t value = 0u;
    s >> value;

    // increment is needed for compatibility with Rust; indices of error codes
    // start from 0 there, while in kagome they must start from 1 because of
    // std::error_code policy
    value++;
    if (value > static_cast<uint8_t>(InvalidTransaction::ExhaustsResources)) {
      v = InvalidTransaction::Custom;
    } else {
      v = static_cast<InvalidTransaction>(value);
    }
    return s;
  }

  enum class UnknownTransaction : uint8_t {
    CannotLookup = 1,
    NoUnsignedValidator,
    Custom
  };

  template <class Stream,
            typename = std::enable_if_t<Stream::is_encoder_stream>>
  Stream &operator<<(Stream &s, const UnknownTransaction &v) {
    // -1 is needed for compatibility with Rust; indices of error codes start
    // from 0 there, while in kagome they must start from 1 because of
    // std::error_code policy
    return s << static_cast<uint8_t>(v) - 1;
  }

  template <class Stream,
            typename = std::enable_if_t<Stream::is_decoder_stream>>
  Stream &operator>>(Stream &s, UnknownTransaction &v) {
    uint8_t value = 0u;
    s >> value;

    // increment is needed for compatibility with Rust; indices of error codes
    // start from 0 there, while in kagome they must start from 1 because of
    // std::error_code policy
    value++;
    if (value > static_cast<uint8_t>(UnknownTransaction::NoUnsignedValidator)) {
      v = UnknownTransaction::Custom;
    } else {
      v = static_cast<UnknownTransaction>(value);
    }
    return s;
  }

  using TransactionValidityError =
      boost::variant<InvalidTransaction, UnknownTransaction>;

  using TransactionValidity =
      boost::variant<ValidTransaction, TransactionValidityError>;
}  // namespace kagome::primitives

OUTCOME_HPP_DECLARE_ERROR(kagome::primitives, InvalidTransaction)
OUTCOME_HPP_DECLARE_ERROR(kagome::primitives, UnknownTransaction)

#endif  // KAGOME_CORE_PRIMITIVES_TRANSACTION_VALIDITY_HPP