@eosrio/node-abieos 2.1.0-beta.0 → 2.2.0

package/src/abi.cpp

@@ -1,297 +0,0 @@
-#include <eosio/abi.hpp>
-#include "abieos.hpp"
-
-using namespace eosio;
-
-namespace {
-
-template <int i>
-bool ends_with(const std::string& s, const char (&suffix)[i]) {
-    return s.size() >= i - 1 && !strcmp(s.c_str() + s.size() - (i - 1), suffix);
-}
-
-template <typename T>
-struct abi_serializer_impl : abi_serializer {
-    void json_to_bin(::abieos::jvalue_to_bin_state& state, bool allow_extensions, const abi_type* type,
-                             bool start) const override {
-        return ::abieos::json_to_bin((T*)nullptr, state, allow_extensions, type, start);
-    }
-    void json_to_bin(::abieos::json_to_bin_state& state, bool allow_extensions, const abi_type* type,
-                             bool start) const override {
-        return ::abieos::json_to_bin((T*)nullptr, state, allow_extensions, type, start);
-    }
-    void bin_to_json(::abieos::bin_to_json_state& state, bool allow_extensions, const abi_type* type,
-                             bool start) const override {
-        return ::abieos::bin_to_json((T*)nullptr, state, allow_extensions, type, start);
-    }
-};
-
-template <typename T>
-constexpr auto abi_serializer_for = abi_serializer_impl<T>{};
-
-abi_type::alias resolve(std::map<std::string, abi_type>& abi_types, const abi_type::alias_def* type, int depth);
-
-template<typename... T, typename... A>
-bool holds_any_alternative(const std::variant<A...>& v) {
-   return (... || std::holds_alternative<T>(v));
-}
-
-template <typename F>
-constexpr void for_each_abi_type(F f) {
-    static_assert(sizeof(float) == 4);
-    static_assert(sizeof(double) == 8);
-
-    using namespace ::abieos;
-    f((bool*)nullptr);
-    f((int8_t*)nullptr);
-    f((uint8_t*)nullptr);
-    f((int16_t*)nullptr);
-    f((uint16_t*)nullptr);
-    f((int32_t*)nullptr);
-    f((uint32_t*)nullptr);
-    f((int64_t*)nullptr);
-    f((uint64_t*)nullptr);
-    f((int128*)nullptr);
-    f((uint128*)nullptr);
-    f((varuint32*)nullptr);
-    f((varint32*)nullptr);
-    f((float*)nullptr);
-    f((double*)nullptr);
-    f((float128*)nullptr);
-    f((time_point*)nullptr);
-    f((time_point_sec*)nullptr);
-    f((block_timestamp*)nullptr);
-    f((name*)nullptr);
-    f((bytes*)nullptr);
-    f((std::string*)nullptr);
-    f((checksum160*)nullptr);
-    f((checksum256*)nullptr);
-    f((checksum512*)nullptr);
-    f((public_key*)nullptr);
-    f((private_key*)nullptr);
-    f((signature*)nullptr);
-    f((symbol*)nullptr);
-    f((symbol_code*)nullptr);
-    f((asset*)nullptr);
-}
-
-abi_type* get_type(std::map<std::string, abi_type>& abi_types,
-                           const std::string& name, int depth) {
-   eosio::check(depth < 32,
-        eosio::convert_abi_error(abi_error::recursion_limit_reached));
-    auto it = abi_types.find(name);
-    if (it == abi_types.end()) {
-        if (ends_with(name, "?")) {
-            auto base = get_type(abi_types, name.substr(0, name.size() - 1), depth + 1);
-            eosio::check(!holds_any_alternative<abi_type::optional, abi_type::array, abi_type::extension>(base->_data),
-                  eosio::convert_abi_error(abi_error::invalid_nesting));
-            auto [iter, success] = abi_types.try_emplace(name, name, abi_type::optional{base}, &abi_serializer_for< ::abieos::pseudo_optional>);
-            return &iter->second;
-        } else if (ends_with(name, "[]")) {
-            auto element = get_type(abi_types, name.substr(0, name.size() - 2), depth + 1);
-            eosio::check(!holds_any_alternative<abi_type::optional, abi_type::array, abi_type::extension>(element->_data),
-                  eosio::convert_abi_error(abi_error::invalid_nesting));
-            auto [iter, success] = abi_types.try_emplace(name, name, abi_type::array{element}, &abi_serializer_for< ::abieos::pseudo_array>);
-            return &iter->second;
-        } else if (ends_with(name, "$")) {
-            auto base = get_type(abi_types, name.substr(0, name.size() - 1), depth + 1);
-            eosio::check(!std::holds_alternative<abi_type::extension>(base->_data),
-                  eosio::convert_abi_error(abi_error::invalid_nesting));
-            auto [iter, success] = abi_types.try_emplace(name, name, abi_type::extension{base}, &abi_serializer_for< ::abieos::pseudo_extension>);
-            return &iter->second;
-        } else
-           eosio::check(false, eosio::convert_abi_error(abi_error::unknown_type));
-    }
-
-    // resolve aliases
-    if (auto* alias = std::get_if<abi_type::alias>(&it->second._data)) {
-        return alias->type;
-    } else if(auto* alias = std::get_if<const abi_type::alias_def*>(&it->second._data)) {
-        auto base = resolve(abi_types, *alias, depth);
-        it->second._data = base;
-        return base.type;
-    }
-
-    return &it->second;
-}
-
-abi_type::struct_ resolve(std::map<std::string, abi_type>& abi_types, const struct_def* type, int depth) {
-   eosio::check(depth < 32,
-        eosio::convert_abi_error(abi_error::recursion_limit_reached));
-    abi_type::struct_ result;
-    if (!type->base.empty()) {
-        auto base = get_type(abi_types, type->base, depth + 1);
-
-        if(auto* base_def = std::get_if<const struct_def*>(&base->_data)) {
-            auto b = resolve(abi_types, *base_def, depth + 1);
-            base->_data = std::move(b);
-        }
-        if(auto* b = std::get_if<abi_type::struct_>(&base->_data)) {
-            result.fields = b->fields;
-        } else {
-           eosio::check(false, eosio::convert_abi_error(abi_error::base_not_a_struct));
-        }
-    }
-    for (auto& field : type->fields) {
-        auto t = get_type(abi_types, field.type, depth + 1);
-        result.fields.push_back(abi_field{field.name, t});
-    }
-    return result;
-}
-
-
-abi_type::variant resolve(std::map<std::string, abi_type>& abi_types, const variant_def* type, int depth) {
-   eosio::check(depth < 32,
-        eosio::convert_abi_error(abi_error::recursion_limit_reached));
-    abi_type::variant result;
-    for (const std::string& field : type->types) {
-        auto t = get_type(abi_types, field, depth + 1);
-        result.push_back({field, t});
-    }
-    return result;
-}
-
-abi_type::alias resolve(std::map<std::string, abi_type>& abi_types, const abi_type::alias_def* type, int depth) {
-    auto t = get_type(abi_types, *type, depth + 1);
-    eosio::check(!std::holds_alternative<abi_type::extension>(t->_data),
-        eosio::convert_abi_error(abi_error::extension_typedef));
-    return abi_type::alias{t};
-}
-
-struct fill_t {
-   std::map<std::string, abi_type>& abi_types;
-   abi_type& type;
-   int depth;
-   template<typename T>
-   auto operator()(T& t) -> std::void_t<decltype(resolve(abi_types, t, depth))> {
-      auto x = resolve(abi_types, t, depth);
-      type._data = std::move(x);
-   }
-   template<typename T>
-   auto operator()(const T& t) {
-   }
-};
-
-void fill(std::map<std::string, abi_type>& abi_types, abi_type& type, int depth) {
-   return std::visit(fill_t{abi_types, type, depth}, type._data);
-}
-
-}
-
-
-const abi_type* eosio::abi::get_type(const std::string& name) {
-   return ::get_type(abi_types, name, 0);
-}
-
-void eosio::convert(const abi_def& abi, eosio::abi& c) {
-    for (auto& a : abi.actions)
-        c.action_types[a.name] = a.type;
-    for (auto& t : abi.tables)
-        c.table_types[t.name] = t.type;
-    for_each_abi_type([&](auto* p) {
-        const char* name = get_type_name(p);
-        c.abi_types.try_emplace(name, name, abi_type::builtin{}, &abi_serializer_for<std::decay_t<decltype(*p)>>);
-    });
-    {
-        c.abi_types.try_emplace("extended_asset", "extended_asset",
-                                abi_type::struct_{nullptr, {{"quantity", &c.abi_types.find("asset")->second},
-                                                            {"contract", &c.abi_types.find("name")->second}}},
-                                &abi_serializer_for<::abieos::pseudo_object>);
-    }
-
-    for (auto& t : abi.types) {
-       eosio::check(!t.new_type_name.empty(),
-            eosio::convert_abi_error(abi_error::missing_name));
-        auto [_, inserted] = c.abi_types.try_emplace(t.new_type_name, t.new_type_name, &t.type, nullptr);
-        eosio::check(inserted,
-            eosio::convert_abi_error(abi_error::redefined_type));
-    }
-    for (auto& s : abi.structs) {
-       eosio::check(!s.name.empty(),
-            eosio::convert_abi_error(abi_error::missing_name));
-        auto [it, inserted] = c.abi_types.try_emplace(s.name, s.name, &s, &abi_serializer_for<::abieos::pseudo_object>);
-        eosio::check(inserted,
-            eosio::convert_abi_error(abi_error::redefined_type));
-    }
-    for (auto& v : abi.variants.value) {
-       eosio::check(!v.name.empty(),
-            eosio::convert_abi_error(abi_error::missing_name));
-        auto [it, inserted] = c.abi_types.try_emplace(v.name, v.name, &v, &abi_serializer_for<::abieos::pseudo_variant>);
-        eosio::check(inserted,
-            eosio::convert_abi_error(abi_error::redefined_type));
-    }
-    for (auto& [_, t] : c.abi_types) {
-        fill(c.abi_types, t, 0);
-    }
-}
-
-void to_abi_def(abi_def& def, const std::string& name, const abi_type::builtin&) {}
-void to_abi_def(abi_def& def, const std::string& name, const abi_type::optional&) {}
-void to_abi_def(abi_def& def, const std::string& name, const abi_type::array&) {}
-void to_abi_def(abi_def& def, const std::string& name, const abi_type::extension&) {}
-
-template<typename T>
-void to_abi_def(abi_def& def, const std::string& name, const T*) {
-   eosio::check(false, eosio::convert_abi_error(eosio::abi_error::bad_abi));
-}
-
-void to_abi_def(abi_def& def, const std::string& name, const abi_type::alias& alias) {
-   def.types.push_back({name, alias.type->name});
-}
-
-void to_abi_def(abi_def& def, const std::string& name, const abi_type::struct_& struct_) {
-   if(name == "extended_asset") return;
-   std::size_t field_offset = 0;
-   std::string base;
-   std::vector<field_def> fields;
-   if(struct_.base) {
-      field_offset = struct_.base->as_struct()->fields.size();
-      base = struct_.base->name;
-   }
-   for(std::size_t i = field_offset; i < struct_.fields.size(); ++i) {
-      const abi_field& field = struct_.fields[i];
-      fields.push_back({field.name, field.type->name});
-   }
-   def.structs.push_back({name, std::move(base), std::move(fields)});
-}
-
-void to_abi_def(abi_def& def, const std::string& name, const abi_type::variant& variant) {
-   std::vector<std::string> types;
-   for(const auto& [name, type] : variant) {
-      types.push_back(type->name);
-   }
-   def.variants.value.push_back({name, std::move(types)});
-}
-
-void eosio::convert(const eosio::abi& abi, eosio::abi_def& def) {
-   def.version = "eosio::abi/1.0";
-   for(auto& [name, type] : abi.abi_types) {
-      std::visit([&name = type.name, &def](const auto& t){ return to_abi_def(def, name, t); }, type._data);
-   }
-}
-
-const abi_serializer* const eosio::object_abi_serializer = &abi_serializer_for< ::abieos::pseudo_object>;
-const abi_serializer* const eosio::variant_abi_serializer = &abi_serializer_for< ::abieos::pseudo_variant>;
-const abi_serializer* const eosio::array_abi_serializer = &abi_serializer_for< ::abieos::pseudo_array>;
-const abi_serializer* const eosio::extension_abi_serializer = &abi_serializer_for< ::abieos::pseudo_extension>;
-const abi_serializer* const eosio::optional_abi_serializer = &abi_serializer_for< ::abieos::pseudo_optional>;
-
-std::vector<char> eosio::abi_type::json_to_bin_reorderable(std::string_view json, std::function<void()> f) const {
-   abieos::jvalue tmp;
-   abieos::json_to_jvalue(tmp, json, f);
-   std::vector<char> result;
-   abieos::json_to_bin(result, this, tmp, f);
-   return result;
-}
-
-std::vector<char> eosio::abi_type::json_to_bin(std::string_view json, std::function<void()> f) const {
-   std::vector<char> result;
-   abieos::json_to_bin(result, this, json, f);
-   return result;
-}
-
-std::string eosio::abi_type::bin_to_json(input_stream& bin, std::function<void()> f) const {
-   std::string result;
-   abieos::bin_to_json(bin, this, result, f);
-   return result;
-}

package/src/abieos.cpp

@@ -1,263 +0,0 @@
-// copyright defined in abieos/LICENSE.txt
-
-#include "abieos.h"
-#include "abieos.hpp"
-
-#include <memory>
-
-inline const bool catch_all = true;
-
-using namespace abieos;
-
-struct abieos_context_s {
-    const char* last_error = "";
-    std::string last_error_buffer{};
-    std::string result_str{};
-    std::vector<char> result_bin{};
-
-    std::map<name, abi> contracts{};
-};
-
-void fix_null_str(const char*& s) {
-    if (!s)
-        s = "";
-}
-
-bool set_error(abieos_context* context, std::string error) noexcept {
-    context->last_error_buffer = std::move(error);
-    context->last_error = context->last_error_buffer.c_str();
-    return false;
-}
-
-template <typename T, typename F>
-auto handle_exceptions(abieos_context* context, T errval, F f) noexcept -> decltype(f()) {
-    if (!context)
-        return errval;
-    try {
-        return f();
-    } catch (std::exception& e) {
-        if (!catch_all)
-            throw;
-        set_error(context, e.what());
-        return errval;
-    } catch (...) {
-        if (!catch_all)
-            throw;
-        set_error(context, "unknown exception");
-        return errval;
-    }
-}
-
-extern "C" abieos_context* abieos_create() {
-    try {
-        return new abieos_context{};
-    } catch (...) {
-        if (!catch_all)
-            throw;
-        return nullptr;
-    }
-}
-
-extern "C" abieos_bool abieos_delete_contract(abieos_context* context, uint64_t contract) {
-    auto itr = context->contracts.find(::abieos::name{contract});
-    if(itr == context->contracts.end()) {
-        return false;
-    } else {
-        context->contracts.erase(itr);
-        return true;
-    }
-}
-
-extern "C" void abieos_destroy(abieos_context* context) { delete context; }
-
-extern "C" const char* abieos_get_error(abieos_context* context) {
-    if (!context)
-        return "context is null";
-    return context->last_error;
-}
-
-extern "C" int abieos_get_bin_size(abieos_context* context) {
-    if (!context)
-        return 0;
-    return context->result_bin.size();
-}
-
-extern "C" const char* abieos_get_bin_data(abieos_context* context) {
-    if (!context)
-        return nullptr;
-    return context->result_bin.data();
-}
-
-extern "C" const char* abieos_get_bin_hex(abieos_context* context) {
-    return handle_exceptions(context, nullptr, [&] {
-        context->result_str.clear();
-        hex(context->result_bin.begin(), context->result_bin.end(), std::back_inserter(context->result_str));
-        return context->result_str.c_str();
-    });
-}
-
-extern "C" uint64_t abieos_string_to_name(abieos_context* context, const char* str) {
-    fix_null_str(str);
-    return eosio::string_to_name(str);
-}
-
-extern "C" const char* abieos_name_to_string(abieos_context* context, uint64_t name) {
-    return handle_exceptions(context, nullptr, [&] {
-        context->result_str = eosio::name_to_string(name);
-        return context->result_str.c_str();
-    });
-}
-
-extern "C" abieos_bool abieos_set_abi(abieos_context* context, uint64_t contract, const char* abi) {
-    fix_null_str(abi);
-    return handle_exceptions(context, false, [&]() {
-        context->last_error = "abi parse error";
-        abi_def def{};
-        std::string error;
-        std::string abi_copy{abi};
-        eosio::json_token_stream stream(abi_copy.data());
-        from_json(def, stream);
-        if (!check_abi_version(def.version, error))
-            return set_error(context, std::move(error));
-        abieos::abi c;
-        convert(def, c);
-        context->contracts.insert_or_assign(name{contract}, std::move(c));
-        return true;
-    });
-}
-
-extern "C" abieos_bool abieos_set_abi_bin(abieos_context* context, uint64_t contract, const char* data, size_t size) {
-    return handle_exceptions(context, false, [&] {
-        context->last_error = "abi parse error";
-        if (!data || !size)
-            return set_error(context, "no data");
-        std::string error;
-        eosio::input_stream stream{data, size};
-        std::string version;
-        from_bin(version, stream);
-        if (!check_abi_version(version, error))
-            return set_error(context, std::move(error));
-        abi_def def{};
-        stream = {data, size};
-        from_bin(def, stream);
-        abieos::abi c;
-        convert(def, c);
-        context->contracts.insert_or_assign(name{contract}, std::move(c));
-        return true;
-    });
-}
-
-extern "C" abieos_bool abieos_set_abi_hex(abieos_context* context, uint64_t contract, const char* hex) {
-    fix_null_str(hex);
-    return handle_exceptions(context, false, [&]() -> abieos_bool {
-        std::vector<char> data;
-        std::string error;
-        if (!unhex(error, hex, hex + strlen(hex), std::back_inserter(data))) {
-            if (!error.empty())
-                set_error(context, std::move(error));
-            return false;
-        }
-        return abieos_set_abi_bin(context, contract, data.data(), data.size());
-    });
-}
-
-extern "C" const char* abieos_get_type_for_action(abieos_context* context, uint64_t contract, uint64_t action) {
-    return handle_exceptions(context, nullptr, [&] {
-        auto contract_it = context->contracts.find(::abieos::name{contract});
-        if (contract_it == context->contracts.end())
-            throw std::runtime_error("contract \"" + eosio::name_to_string(contract) + "\" is not loaded");
-        auto& c = contract_it->second;
-
-        auto action_it = c.action_types.find(name{action});
-        if (action_it == c.action_types.end())
-            throw std::runtime_error("contract \"" + eosio::name_to_string(contract) + "\" does not have action \"" +
-                                     eosio::name_to_string(action) + "\"");
-        return action_it->second.c_str();
-    });
-}
-
-extern "C" const char* abieos_get_type_for_table(abieos_context* context, uint64_t contract, uint64_t table) {
-    return handle_exceptions(context, nullptr, [&] {
-        auto contract_it = context->contracts.find(::abieos::name{contract});
-        if (contract_it == context->contracts.end())
-            throw std::runtime_error("contract \"" + eosio::name_to_string(contract) + "\" is not loaded");
-        auto& c = contract_it->second;
-
-        auto table_it = c.table_types.find(name{table});
-        if (table_it == c.table_types.end())
-            throw std::runtime_error("contract \"" + eosio::name_to_string(contract) + "\" does not have table \"" +
-                                     eosio::name_to_string(table) + "\"");
-        return table_it->second.c_str();
-    });
-}
-
-extern "C" abieos_bool abieos_json_to_bin(abieos_context* context, uint64_t contract, const char* type,
-                                          const char* json) {
-    fix_null_str(type);
-    fix_null_str(json);
-    return handle_exceptions(context, false, [&] {
-        context->last_error = "json parse error";
-        auto contract_it = context->contracts.find(::abieos::name{contract});
-        if (contract_it == context->contracts.end())
-            return set_error(context, "contract \"" + eosio::name_to_string(contract) + "\" is not loaded");
-        std::string error;
-        auto t = contract_it->second.get_type(type);
-        context->result_bin.clear();
-        context->result_bin = t->json_to_bin(json);
-        return true;
-    });
-}
-
-extern "C" abieos_bool abieos_json_to_bin_reorderable(abieos_context* context, uint64_t contract, const char* type,
-                                                      const char* json) {
-    fix_null_str(type);
-    fix_null_str(json);
-    return handle_exceptions(context, false, [&] {
-        context->last_error = "json parse error";
-        auto contract_it = context->contracts.find(::abieos::name{contract});
-        if (contract_it == context->contracts.end())
-            return set_error(context, "contract \"" + eosio::name_to_string(contract) + "\" is not loaded");
-        std::string error;
-        auto t = contract_it->second.get_type(type);
-        context->result_bin.clear();
-        context->result_bin = t->json_to_bin_reorderable(json);
-        return true;
-    });
-}
-
-extern "C" const char* abieos_bin_to_json(abieos_context* context, uint64_t contract, const char* type,
-                                          const char* data, size_t size) {
-    fix_null_str(type);
-    return handle_exceptions(context, nullptr, [&]() -> const char* {
-        if (!data)
-            size = 0;
-        context->last_error = "binary decode error";
-        auto contract_it = context->contracts.find(::abieos::name{contract});
-        std::string error;
-        if (contract_it == context->contracts.end()) {
-            (void)set_error(error, "contract \"" + eosio::name_to_string(contract) + "\" is not loaded");
-            return nullptr;
-        }
-        auto t = contract_it->second.get_type(type);
-        eosio::input_stream bin{data, size};
-        context->result_str = t->bin_to_json(bin);
-        if (bin.pos != bin.end)
-            throw std::runtime_error("Extra data");
-        return context->result_str.c_str();
-    });
-}
-
-extern "C" const char* abieos_hex_to_json(abieos_context* context, uint64_t contract, const char* type,
-                                          const char* hex) {
-    fix_null_str(hex);
-    return handle_exceptions(context, nullptr, [&]() -> const char* {
-        std::vector<char> data;
-        std::string error;
-        if (!unhex(error, hex, hex + strlen(hex), std::back_inserter(data))) {
-            if (!error.empty())
-                set_error(context, std::move(error));
-            return nullptr;
-        }
-        return abieos_bin_to_json(context, contract, type, data.data(), data.size());
-    });
-}

package/src/abieos.h

@@ -1,76 +0,0 @@
-// copyright defined in abieos/LICENSE.txt
-
-#pragma once
-
-#include <stddef.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct abieos_context_s abieos_context;
-typedef int abieos_bool;
-
-// Create a context. The context holds all memory allocated by functions in this header. Returns null on failure.
-abieos_context* abieos_create();
-
-// Destroy a context.
-void abieos_destroy(abieos_context* context);
-
-// Delete a contract from context
-abieos_bool abieos_delete_contract(abieos_context* context, uint64_t contract);
-
-// Get last error. Never returns null. The context owns the returned string.
-const char* abieos_get_error(abieos_context* context);
-
-// Get generated binary. The context owns the returned memory. Functions return null on error; use abieos_get_error to
-// retrieve error.
-int abieos_get_bin_size(abieos_context* context);
-const char* abieos_get_bin_data(abieos_context* context);
-
-// Convert generated binary to hex. The context owns the returned string. Returns null on error; use abieos_get_error to
-// retrieve error.
-const char* abieos_get_bin_hex(abieos_context* context);
-
-// Name conversion. The context owns the returned memory. Functions return null on error; use abieos_get_error to
-// retrieve error.
-uint64_t abieos_string_to_name(abieos_context* context, const char* str);
-const char* abieos_name_to_string(abieos_context* context, uint64_t name);
-
-// Set abi (JSON format). Returns false on error.
-abieos_bool abieos_set_abi(abieos_context* context, uint64_t contract, const char* abi);
-
-// Set abi (binary format). Returns false on error.
-abieos_bool abieos_set_abi_bin(abieos_context* context, uint64_t contract, const char* data, size_t size);
-
-// Set abi (hex format). Returns false on error.
-abieos_bool abieos_set_abi_hex(abieos_context* context, uint64_t contract, const char* hex);
-
-// Get the type name for an action. The contract owns the returned memory. Returns null on error; use abieos_get_error
-// to retrieve error.
-const char* abieos_get_type_for_action(abieos_context* context, uint64_t contract, uint64_t action);
-
-// Get the type name for a table. The contract owns the returned memory. Returns null on error; use abieos_get_error
-// to retrieve error.
-const char* abieos_get_type_for_table(abieos_context* context, uint64_t contract, uint64_t table);
-
-// Convert json to binary. Use abieos_get_bin_* to retrieve result. Returns false on error.
-abieos_bool abieos_json_to_bin(abieos_context* context, uint64_t contract, const char* type, const char* json);
-
-// Convert json to binary. Allow json field reordering. Use abieos_get_bin_* to retrieve result. Returns false on error.
-abieos_bool abieos_json_to_bin_reorderable(abieos_context* context, uint64_t contract, const char* type,
-                                           const char* json);
-
-// Convert binary to json. The context owns the returned string. Returns null on error; use abieos_get_error to retrieve
-// error.
-const char* abieos_bin_to_json(abieos_context* context, uint64_t contract, const char* type, const char* data,
-                               size_t size);
-
-// Convert hex to json. The context owns the returned memory. Returns null on error; use abieos_get_error to retrieve
-// error.
-const char* abieos_hex_to_json(abieos_context* context, uint64_t contract, const char* type, const char* hex);
-
-#ifdef __cplusplus
-}
-#endif