apply_result.hpp

Go to the documentation of this file.

#ifndef KAGOME_CORE_PRIMITIVES_APPLY_RESULT_HPP
#define KAGOME_CORE_PRIMITIVES_APPLY_RESULT_HPP

#include <boost/variant.hpp>

#include "primitives/arithmetic_error.hpp"
#include "primitives/token_error.hpp"
#include "primitives/transaction_validity.hpp"
#include "scale/scale.hpp"
#include "scale/tie.hpp"

namespace kagome::primitives {

  // Implementation according to
  // https://github.com/paritytech/substrate/blob/7dcc77b982f59eaf6cec19499d981164b04a255d/primitives/runtime/src/lib.rs#L459
  // and
  // https://w3f-research.readthedocs.io/en/latest/_static/pdfview/viewer.html?file=https://w3f.github.io/polkadot-spec/spec/host/nightly.pdf#label329

  class DispatchSuccess {};
  SCALE_EMPTY_CODER(DispatchSuccess);

  namespace dispatch_error {
    struct Other {
      std::string value;
    };
    // string value is not currently encodes in rust implementation,
    // thus we use empty coder
    SCALE_EMPTY_CODER(Other);
    struct CannotLookup {};
    SCALE_EMPTY_CODER(CannotLookup);
    struct BadOrigin {};
    SCALE_EMPTY_CODER(BadOrigin);
    struct Module {
      uint8_t index;
      uint8_t error;
      std::optional<std::string>
          message;  // not currently used in rust impl, thus not scale encoded
    };

    template <typename Stream,
              typename = std::enable_if_t<Stream::is_encoder_stream>>
    Stream &operator<<(Stream &s, const Module &v) {
      return s << v.index << v.error;
    }

    template <typename Stream,
              typename = std::enable_if_t<Stream::is_decoder_stream>>
    Stream &operator>>(Stream &s, Module &v) {
      s >> v.index >> v.error;
      return s;
    }

    struct ConsumerRemaining {};
    SCALE_EMPTY_CODER(ConsumerRemaining);
    struct NoProviders {};
    SCALE_EMPTY_CODER(NoProviders);
    struct Token {
      SCALE_TIE(1);

      TokenError error;
    };

    struct Arithmetic {
      SCALE_TIE(1);

      ArithmeticError error;
    };
  }  // namespace dispatch_error

  namespace de = dispatch_error;
  using DispatchError = boost::variant<de::Other,
                                       de::CannotLookup,
                                       de::BadOrigin,
                                       de::Module,
                                       de::ConsumerRemaining,
                                       de::NoProviders,
                                       de::Token,
                                       de::Arithmetic>;

  using DispatchOutcome = boost::variant<DispatchSuccess, DispatchError>;

  using ApplyExtrinsicResult =
      boost::variant<DispatchOutcome, TransactionValidityError>;

}  // namespace kagome::primitives

#endif  // KAGOME_CORE_PRIMITIVES_APPLY_RESULT_HPP