Fix payment_queryInfo

core/api/jrpc/value_converter.hpp

@@ -102,6 +102,13 @@ namespace kagome::api {
     return ret;
   }
 
+  inline jsonrpc::Value makeValue(const primitives::Weight &val) {
+    jStruct data;
+    data["ref_time"] = static_cast<int64_t>(*val.ref_time);
+    data["proof_size"] = static_cast<int64_t>(*val.proof_size);
+    return data;
+  }
+
   inline jsonrpc::Value makeValue(const primitives::OldWeight &val) {
     jsonrpc::Value ret(static_cast<int64_t>(*val));
     return ret;

core/api/service/payment/impl/payment_api_impl.cpp

@@ -20,7 +20,7 @@ namespace kagome::api {
     BOOST_ASSERT(block_tree_);
   }
 
-  outcome::result<primitives::RuntimeDispatchInfo<primitives::OldWeight>>
+  outcome::result<primitives::RuntimeDispatchInfo<primitives::Weight>>
   PaymentApiImpl::queryInfo(const primitives::Extrinsic &extrinsic,
                             uint32_t len,
                             OptionalHashRef at) const {

core/api/service/payment/impl/payment_api_impl.hpp

@@ -24,7 +24,7 @@ namespace kagome::api {
                    std::shared_ptr<const blockchain::BlockTree> block_tree);
     ~PaymentApiImpl() override = default;
 
-    outcome::result<primitives::RuntimeDispatchInfo<primitives::OldWeight>>
+    outcome::result<primitives::RuntimeDispatchInfo<primitives::Weight>>
     queryInfo(const primitives::Extrinsic &extrinsic,
               uint32_t len,
               OptionalHashRef at) const override;

core/api/service/payment/payment_api.hpp

@@ -23,7 +23,7 @@ namespace kagome::api {
     virtual ~PaymentApi() = default;
 
     virtual outcome::result<
-        primitives::RuntimeDispatchInfo<primitives::OldWeight>>
+        primitives::RuntimeDispatchInfo<primitives::Weight>>
     queryInfo(const primitives::Extrinsic &extrinsic,
               uint32_t len,
               OptionalHashRef at) const = 0;

core/api/service/payment/requests/query_info.hpp

@@ -17,27 +17,27 @@ namespace kagome::api::payment::request {
 
   class QueryInfo final
       : public details::RequestType<
-            primitives::RuntimeDispatchInfo<primitives::OldWeight>,
+            primitives::RuntimeDispatchInfo<primitives::Weight>,
             std::string,
-            std::string> {
+            std::optional<std::string>> {
    public:
     explicit QueryInfo(std::shared_ptr<PaymentApi> api) : api_(std::move(api)) {
       BOOST_ASSERT(api_);
-    };
+    }
 
-    outcome::result<primitives::RuntimeDispatchInfo<primitives::OldWeight>>
+    outcome::result<primitives::RuntimeDispatchInfo<primitives::Weight>>
     execute() override {
       auto ext_hex = getParam<0>();
       OUTCOME_TRY(ext_bytes, common::unhexWith0x(ext_hex));
 
       OUTCOME_TRY(extrinsic, scale::decode<primitives::Extrinsic>(ext_bytes));
 
-      auto at_hex = getParam<1>();
-      if (at_hex.empty()) {
+      auto at_hex_opt = getParam<1>();
+      if (not at_hex_opt.has_value()) {
         return api_->queryInfo(extrinsic, ext_bytes.size(), std::nullopt);
       }
       common::Hash256 at_hash;
-      OUTCOME_TRY(at, common::unhexWith0x(at_hex));
+      OUTCOME_TRY(at, common::unhexWith0x(at_hex_opt.value()));
       BOOST_ASSERT(at.size() == common::Hash256::size());
       std::copy_n(at.cbegin(), common::Hash256::size(), at_hash.begin());
       return api_->queryInfo(extrinsic, ext_bytes.size(), std::cref(at_hash));

core/api/transport/impl/ws/ws_session.cpp

@@ -13,6 +13,7 @@
 #include <boost/beast/http/string_body.hpp>
 #include <boost/config.hpp>
 #include <libp2p/outcome/outcome.hpp>
+#include "log/logger.hpp"
 
 namespace boost::beast {
   template <class NextLayer, class DynamicBuffer>
@@ -138,6 +139,7 @@ namespace kagome::api {
   }
 
   void WsSession::respond(std::string_view response) {
+    SL_INFO(logger_, "Responding: {}", response);
     post([self{shared_from_this()}, response{std::string{response}}] {
       if (not self->is_ws_) {
         self->sessionClose();

core/api/transport/session.hpp

@@ -14,6 +14,7 @@
 #include <boost/signals2/signal.hpp>
 
 #include "api/transport/rpc_io_context.hpp"
+#include "log/logger.hpp"
 
 namespace kagome::api {
   enum struct SessionType {
@@ -69,6 +70,7 @@ namespace kagome::api {
      */
     void processRequest(std::string_view request,
                         std::shared_ptr<Session> session) {
+      SL_INFO(logger_, "Processing request: {}", request);
       on_request_(request, std::move(session));
     }
 
@@ -118,6 +120,7 @@ namespace kagome::api {
    private:
     std::function<OnRequestSignature> on_request_;  ///< `on request` callback
     OnCloseHandler on_close_;
+    log::Logger logger_ = log::createLogger("Session");
   };
 
 }  // namespace kagome::api

core/host_api/impl/offchain_extension.cpp

@@ -110,10 +110,6 @@ namespace kagome::host_api {
       storage_type = StorageType::Persistent;
     } else if (kind == 2) {
       storage_type = StorageType::Local;
-    } else if (kind == 0) {
-      // TODO(xDimon): Remove this if-branch when it will be fixed it substrate
-      //  issue: https://github.com/soramitsu/kagome/issues/997
-      storage_type = StorageType::Persistent;
     } else {
       throw std::invalid_argument(
           "Method was called with unknown kind of storage");
@@ -137,10 +133,6 @@ namespace kagome::host_api {
       storage_type = StorageType::Persistent;
     } else if (kind == 2) {
       storage_type = StorageType::Local;
-    } else if (kind == 0) {
-      // TODO(xDimon): Remove this if-branch when it will be fixed it substrate
-      //  issue: https://github.com/soramitsu/kagome/issues/997
-      storage_type = StorageType::Persistent;
     } else {
       throw std::invalid_argument(
           "Method was called with unknown kind of storage");
@@ -166,10 +158,6 @@ namespace kagome::host_api {
       storage_type = StorageType::Persistent;
     } else if (kind == 2) {
       storage_type = StorageType::Local;
-    } else if (kind == 0) {
-      // TODO(xDimon): Remove this if-branch when it will be fixed it substrate
-      //  issue: https://github.com/soramitsu/kagome/issues/997
-      storage_type = StorageType::Persistent;
     } else {
       throw std::invalid_argument(
           "Method was called with unknown kind of storage");
@@ -208,10 +196,6 @@ namespace kagome::host_api {
       storage_type = StorageType::Persistent;
     } else if (kind == 2) {
       storage_type = StorageType::Local;
-    } else if (kind == 0) {
-      // TODO(xDimon): Remove this if-branch when it will be fixed it substrate
-      //  issue: https://github.com/soramitsu/kagome/issues/997
-      storage_type = StorageType::Persistent;
     } else {
       throw std::invalid_argument(
           "Method was called with unknown kind of storage");

core/primitives/runtime_dispatch_info.hpp

@@ -58,7 +58,6 @@ namespace kagome::primitives {
   template <typename Stream,
             typename = std::enable_if_t<Stream::is_decoder_stream>>
   Stream &operator>>(Stream &stream, DispatchClass &dispatch_class) {
-    std::ignore = stream.nextByte();
     uint8_t dispatch_class_byte;
     stream >> dispatch_class_byte;
     dispatch_class = static_cast<DispatchClass>(dispatch_class_byte);

core/runtime/runtime_api/impl/transaction_payment_api.cpp

@@ -16,6 +16,8 @@ OUTCOME_CPP_DEFINE_CATEGORY(kagome::runtime,
   switch (err) {
     case E::TRANSACTION_PAYMENT_API_NOT_FOUND:
       return "Transaction payment runtime API is not found in the runtime";
+    case TransactionPaymentApiImpl::Error::API_BELOW_VERSION_2_NOT_SUPPORTED:
+      return "API below version 2 is not supported";
   }
   return "Unknown TransactionPaymentApiImpl error";
 }
@@ -32,7 +34,7 @@ namespace kagome::runtime {
     BOOST_ASSERT(hasher_);
   }
 
-  outcome::result<primitives::RuntimeDispatchInfo<primitives::OldWeight>>
+  outcome::result<primitives::RuntimeDispatchInfo<primitives::Weight>>
   TransactionPaymentApiImpl::query_info(const primitives::BlockHash &block,
                                         const primitives::Extrinsic &ext,
                                         uint32_t len) {
@@ -56,19 +58,18 @@ namespace kagome::runtime {
     auto api_version = res->second;
     OUTCOME_TRY(ctx, executor_->ctx().ephemeralAt(block));
     if (api_version < 2) {
-      return executor_
-          ->call<primitives::RuntimeDispatchInfo<primitives::OldWeight>>(
-              ctx, "TransactionPaymentApi_query_info", ext.data, len);
+      return Error::API_BELOW_VERSION_2_NOT_SUPPORTED;
     }
     OUTCOME_TRY(
         result,
         executor_->call<primitives::RuntimeDispatchInfo<primitives::Weight>>(
             ctx, "TransactionPaymentApi_query_info", ext.data, len));
-    primitives::RuntimeDispatchInfo<primitives::OldWeight> old_format_result;
-    old_format_result.dispatch_class = result.dispatch_class;
-    old_format_result.partial_fee = result.partial_fee;
-    old_format_result.weight = result.weight.ref_time;
-    return old_format_result;
+    primitives::RuntimeDispatchInfo<primitives::Weight> weight_result;
+    weight_result.dispatch_class = result.dispatch_class;
+    weight_result.partial_fee = result.partial_fee;
+    weight_result.weight.ref_time = result.weight.ref_time;
+    weight_result.weight.proof_size = result.weight.proof_size;
+    return result;
   }
 
 }  // namespace kagome::runtime

core/runtime/runtime_api/impl/transaction_payment_api.hpp

@@ -19,13 +19,15 @@ namespace kagome::runtime {
     enum class Error {
       // Transaction payment runtime API is not found in the runtime
       TRANSACTION_PAYMENT_API_NOT_FOUND = 1,
+      // API below version 2 is not supported (needed for query_info)
+      API_BELOW_VERSION_2_NOT_SUPPORTED = 2,
     };
 
     explicit TransactionPaymentApiImpl(std::shared_ptr<Executor> executor,
                                        std::shared_ptr<Core> core_api,
                                        std::shared_ptr<crypto::Hasher> hasher);
 
-    outcome::result<primitives::RuntimeDispatchInfo<primitives::OldWeight>>
+    outcome::result<primitives::RuntimeDispatchInfo<primitives::Weight>>
     query_info(const primitives::BlockHash &block,
                const primitives::Extrinsic &ext,
                uint32_t len) override;

core/runtime/runtime_api/transaction_payment_api.hpp

@@ -18,7 +18,7 @@ namespace kagome::runtime {
     virtual ~TransactionPaymentApi() = default;
 
     virtual outcome::result<
-        primitives::RuntimeDispatchInfo<primitives::OldWeight>>
+        primitives::RuntimeDispatchInfo<primitives::Weight>>
     query_info(const primitives::BlockHash &block,
                const primitives::Extrinsic &ext,
                uint32_t len) = 0;