#include <abi_data_handler.hpp>

Classes
class	shared_provider

Public Member Functions
	abi_data_handler (exception_handler except_handler)

void	add_abi (const chain::name &name, const chain::abi_def &abi)

std::tuple< fc::variant, std::optional< fc::variant > >	serialize_to_variant (const std::variant< action_trace_v0, action_trace_v1 > &action, const yield_function &yield)

Detailed Description

Data Handler that uses sysio::chain::abi_serializer to decode data with a known set of ABI's Can be used directly as a Data_handler_provider OR shared between request_handlers using the ::shared_provider abstraction.

Definition at line 19 of file abi_data_handler.hpp.

Constructor & Destructor Documentation

◆ abi_data_handler()

sysio::trace_api::abi_data_handler::abi_data_handler ( exception_handler except_handler )

inlineexplicit

Definition at line 21 of file abi_data_handler.hpp.

      :except_handler( std::move( except_handler ) )
      {
      }

Member Function Documentation

◆ add_abi()

void sysio::trace_api::abi_data_handler::add_abi	(	const chain::name &	name,
		const chain::abi_def &	abi )

Add an ABI definition to this data handler

Parameters

name	- the name of the account/contract that this ABI belongs to
abi	- the ABI definition of that ABI

Definition at line 6 of file abi_data_handler.cpp.

                                                                                  {
      // currently abis are operator provided so no need to protect against abuse
      abi_serializer_by_account.emplace(name,
            std::make_shared<chain::abi_serializer>(abi, chain::abi_serializer::create_yield_function(fc::microseconds::maximum())));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ serialize_to_variant()

std::tuple< fc::variant, std::optional< fc::variant > > sysio::trace_api::abi_data_handler::serialize_to_variant	(	const std::variant< action_trace_v0, action_trace_v1 > &	action,
		const yield_function &	yield )

Given an action trace, produce a tuple representing the data and return_value fields in the trace

Parameters

action	- trace of the action including metadata necessary for finding the ABI
yield	- a yield function to allow cooperation during long running tasks

Returns: tuple where the first element is a variant representing the data field of the action interpreted by known ABIs OR an empty variant, and the second element represents the return_value field of the trace.

Definition at line 12 of file abi_data_handler.cpp.

                                                                                                                                                                               {
      auto account = std::visit([](auto &&action) -> auto { return action.account; }, action);
 
      if (abi_serializer_by_account.count(account) > 0) {
         const auto &serializer_p = abi_serializer_by_account.at(account);
         auto action_name = std::visit([](auto &&action) -> auto { return action.action; }, action);
         auto type_name = serializer_p->get_action_type(action_name);
 
         if (!type_name.empty()) {
            try {
               // abi_serializer expects a yield function that takes a recursion depth
               auto abi_yield = [yield](size_t recursion_depth) {
                  yield();
                  SYS_ASSERT( recursion_depth < chain::abi_serializer::max_recursion_depth, chain::abi_recursion_depth_exception,
                              "exceeded max_recursion_depth ${r} ", ("r", chain::abi_serializer::max_recursion_depth) );
               };
               return std::visit([&](auto &&action) -> std::tuple<fc::variant, std::optional<fc::variant>> {
                  using T = std::decay_t<decltype(action)>;
                  std::optional<fc::variant> ret_data;
                  auto params = serializer_p->binary_to_variant(type_name, action.data, abi_yield);
                  if constexpr (std::is_same_v<T, action_trace_v1>) {
                     if(action.return_value.size() > 0) {
                        ret_data = serializer_p->binary_to_variant(type_name, action.return_value, abi_yield);
                     }
                  }
                  return {params, ret_data};
               }, action);
            } catch (...) {
               except_handler(MAKE_EXCEPTION_WITH_CONTEXT(std::current_exception()));
            }
         }
      }
 
      return {};
   }