@eosrio/node-abieos 2.1.1 → 2.2.0

package/src/abi.cpp

@@ -1,274 +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);
-    std::apply([&f](auto&& ...t) { (f(&t), ...); }, basic_abi_types{});
-}
-
-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 (auto& r : abi.action_results.value)
-        c.action_result_types[r.name] = r.result_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);
-    }
-
-    for (const auto& [key, val] : abi.kv_tables.value) {
-        std::vector<char> bytes;
-        eosio::vector_stream strm(bytes);
-        to_json(val, strm);
-        c.kv_tables.try_emplace(key, bytes.begin(), bytes.end());
-    }
-}
-
-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,334 +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({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({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" const char* abieos_get_kv_table_def(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.kv_tables.find(name{table});
-        if (table_it == c.kv_tables.end())
-            throw std::runtime_error("contract \"" + eosio::name_to_string(contract) + "\" does not have kv table \"" +
-                                     eosio::name_to_string(table) + "\"");
-        return table_it->second.c_str();
-    });
-}
-
-extern "C" const char* abieos_get_type_for_action_result(abieos_context* context, uint64_t contract,
-                                                         uint64_t action_result) {
-    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_result_it = c.action_result_types.find(name{action_result});
-        if (action_result_it == c.action_result_types.end())
-            throw std::runtime_error("contract \"" + eosio::name_to_string(contract) +
-                                     "\" does not have action_result \"" + eosio::name_to_string(action_result) + "\"");
-        return action_result_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());
-    });
-}
-
-extern "C" abieos_bool abieos_abi_json_to_bin(abieos_context* context, const char* abi_json) {
-    fix_null_str(abi_json);
-    return handle_exceptions(context, false, [&] {
-        std::string abi_copy{abi_json};
-        eosio::json_token_stream json_stream(abi_copy.data());
-        abi_def def{};
-        std::string error;
-        from_json(def, json_stream);
-        if (!check_abi_version(def.version, error)) {
-            return set_error(context, std::move(error));
-        }
-        context->result_bin = convert_to_bin(def);
-        return true;
-    });
-}
-
-extern "C" const char* abieos_abi_bin_to_json(abieos_context* context, const char* abi_bin_data,
-                                              const size_t abi_bin_data_size) {
-    return handle_exceptions(context, nullptr, [&]() -> const char* {
-        if (!abi_bin_data || abi_bin_data_size == 0) {
-            set_error(context, "no data");
-            return nullptr;
-        }
-        eosio::input_stream bin_stream{abi_bin_data, abi_bin_data_size};
-        abi_def def{};
-        from_bin(def, bin_stream);
-        std::string error;
-        if (!check_abi_version(def.version, error)) {
-            set_error(context, std::move(error));
-            return nullptr;
-        }
-        std::vector<char> bytes;
-        eosio::vector_stream byte_stream(bytes);
-        to_json(def, byte_stream);
-
-        context->result_str.assign(bytes.begin(), bytes.end());
-        return context->result_str.c_str();
-    });
-}