@eosrio/node-abieos 2.1.1 → 2.2.0

package/include/eosio/convert.hpp

@@ -1,95 +0,0 @@
-#pragma once
-
-#include "for_each_field.hpp"
-#include "stream.hpp"
-#include <optional>
-#include <type_traits>
-#include <utility>
-#include <variant>
-#include <vector>
-
-namespace eosio {
-struct no_conversion {
-   using reverse = no_conversion;
-};
-struct widening_conversion;
-// Fields must match exactly
-struct strict_conversion {
-   using reverse = strict_conversion;
-};
-// Can discard some fields
-struct narrowing_conversion {
-   using reverse = widening_conversion;
-};
-// Can default construct some fields
-struct widening_conversion {
-   using reverse = narrowing_conversion;
-};
-
-no_conversion conversion_kind(...);
-void          serialize_as(...);
-
-template <typename T>
-using serialization_type = decltype(serialize_as(std::declval<T>()));
-
-template <typename T, typename U>
-using conversion_kind_t =
-      std::conditional_t<std::is_same_v<decltype(conversion_kind(std::declval<T>(), std::declval<U>())), no_conversion>,
-                         typename decltype(conversion_kind(std::declval<U>(), std::declval<T>()))::reverse,
-                         decltype(conversion_kind(std::declval<T>(), std::declval<U>()))>;
-
-template <typename Field, typename T, typename U, typename F>
-auto convert_impl(Field field, const T& src, U& dst, F&& f, int)
-      -> std::void_t<decltype(field(&src)), decltype(field(&dst))> {
-   convert(field(&src), field(&dst), f);
-}
-
-template <typename Field, typename T, typename U, typename F>
-auto convert_impl(Field field, const T& src, U& dst, F&& f, long) {
-   static_assert(!std::is_same_v<conversion_kind_t<T, U>, strict_conversion>, "Member not found");
-   static_assert(!std::is_same_v<conversion_kind_t<T, U>, widening_conversion>, "Member not found");
-}
-
-inline constexpr auto choose_first  = [](auto src, auto dest) { return src; };
-inline constexpr auto choose_second = [](auto src, auto dest) { return dest; };
-
-// TODO: add some validation
-
-template <typename T, typename U, typename F>
-void convert(const T& src, U& dst, F&& chooser) {
-   if constexpr (std::is_same_v<T, U>) {
-      dst = src;
-   } else {
-      static_assert(!std::is_same_v<conversion_kind_t<T, U>, no_conversion>, "Conversion not defined");
-      for_each_field<std::decay_t<decltype(*chooser((T*)nullptr, (U*)nullptr))>>(
-            [&](const char*, auto field) { convert_impl(field, src, dst, chooser, 0); });
-   }
-}
-
-template <typename... T, typename U, typename F>
-void convert(const std::variant<T...>& src, U& dst, F&& chooser) {
-   std::visit([&](auto& src) { return convert(src, dst, chooser); }, src);
-}
-
-template <typename T, typename U, typename F>
-void convert(const std::vector<T>& src, std::vector<U>& dst, F&& chooser) {
-   dst.resize(src.size());
-   for (std::size_t i = 0; i < src.size(); ++i) { convert(src[i], dst[i], chooser); }
-}
-
-template <typename T, typename U, typename F>
-void convert(const std::optional<T>& src, std::optional<U>& dst, F&& chooser) {
-   if (src) {
-      dst.emplace();
-      convert(*src, *dst, chooser);
-   } else {
-      dst = std::nullopt;
-   }
-}
-
-struct stream;
-template <typename F>
-void convert(const input_stream& src, std::vector<char>& dst, F&& chooser) {
-   dst.assign(src.pos, src.end);
-}
-} // namespace eosio

package/include/eosio/crypto.hpp

@@ -1,148 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include "operators.hpp"
-#include "reflection.hpp"
-#include <string>
-#include <variant>
-#include <vector>
-#include <array>
-
-namespace eosio {
-
-/**
- *  @defgroup public_key Public Key Type
- *  @ingroup core
- *  @ingroup types
- *  @brief Specifies public key type
- */
-
-/**
- *  EOSIO ECC public key data
- *
- *  Fixed size representation of either a K1 or R1 compressed public key
-
- *  @ingroup public_key
- */
-using ecc_public_key = std::array<char, 33>;
-
-/**
- *  EOSIO WebAuthN public key
- *
- *  @ingroup public_key
- */
-struct webauthn_public_key {
-   /**
-    * Enumeration of the various results of a Test of User Presence
-    * @see https://w3c.github.io/webauthn/#test-of-user-presence
-    */
-   enum class user_presence_t : uint8_t { USER_PRESENCE_NONE, USER_PRESENCE_PRESENT, USER_PRESENCE_VERIFIED };
-
-   /**
-    * The ECC key material
-    */
-   ecc_public_key key;
-
-   /**
-    * expected result of the test of user presence for a valid signature
-    * @see https://w3c.github.io/webauthn/#test-of-user-presence
-    */
-   user_presence_t user_presence;
-
-   /**
-    * the Relying Party Identifier for WebAuthN
-    * @see https://w3c.github.io/webauthn/#relying-party-identifier
-    */
-   std::string rpid;
-};
-EOSIO_REFLECT(webauthn_public_key, key, user_presence, rpid);
-EOSIO_COMPARE(webauthn_public_key);
-
-/**
- *  EOSIO Public Key
- *
- *  A public key is a variant of
- *   0 : a ECC K1 public key
- *   1 : a ECC R1 public key
- *   2 : a WebAuthN public key (requires the host chain to activate the WEBAUTHN_KEY consensus upgrade)
- *
- *  @ingroup public_key
- */
-using public_key = std::variant<ecc_public_key, ecc_public_key, webauthn_public_key>;
-
-using ecc_private_key = std::array<char, 32>;
-using private_key     = std::variant<ecc_private_key, ecc_private_key>;
-
-/**
- *  EOSIO ECC signature data
- *
- *  Fixed size representation of either a K1 or R1 ECC compact signature
-
- *  @ingroup signature
- */
-using ecc_signature = std::array<char, 65>;
-
-struct webauthn_signature {
-   /**
-    * The ECC signature data
-    */
-   ecc_signature compact_signature;
-
-   /**
-    * The Encoded Authenticator Data returned from WebAuthN ceremony
-    * @see https://w3c.github.io/webauthn/#sctn-authenticator-data
-    */
-   std::vector<std::uint8_t> auth_data;
-
-   /**
-    * the JSON encoded Collected Client Data from a WebAuthN ceremony
-    * @see https://w3c.github.io/webauthn/#dictdef-collectedclientdata
-    */
-   std::string client_json;
-};
-
-EOSIO_REFLECT(webauthn_signature, compact_signature, auth_data, client_json);
-EOSIO_COMPARE(webauthn_signature);
-
-using signature = std::variant<ecc_signature, ecc_signature, webauthn_signature>;
-constexpr const char* get_type_name(public_key*) { return "public_key"; }
-constexpr const char* get_type_name(private_key*) { return "private_key"; }
-constexpr const char* get_type_name(signature*) { return "signature"; }
-
-std::string public_key_to_string(const public_key& obj);
-public_key  public_key_from_string(std::string_view s);
-std::string private_key_to_string(const private_key& obj);
-private_key private_key_from_string(std::string_view s);
-std::string signature_to_string(const signature& obj);
-signature   signature_from_string(std::string_view s);
-
-template <typename S>
-void to_json(const public_key& obj, S& stream) {
-   to_json(public_key_to_string(obj), stream);
-}
-template <typename S>
-void from_json(public_key& obj, S& stream) {
-   auto s = stream.get_string();
-   obj = public_key_from_string(s);
-}
-template <typename S>
-void to_json(const private_key& obj, S& stream) {
-   to_json(private_key_to_string(obj), stream);
-}
-template <typename S>
-void from_json(private_key& obj, S& stream) {
-   obj = private_key_from_string(stream.get_string());
-}
-template <typename S>
-void to_json(const signature& obj, S& stream) {
-   return to_json(signature_to_string(obj), stream);
-}
-template <typename S>
-void from_json(signature& obj, S& stream) {
-   obj = signature_from_string(stream.get_string());
-}
-
-std::string to_base58(const char* d, size_t s );
-std::vector<char> from_base58(const std::string_view& s);
-
-} // namespace eosio

package/include/eosio/eosio_outcome.hpp

@@ -1,41 +0,0 @@
-#pragma once
-
-#if defined(__eosio_cdt__)
-#   define OUTCOME_DISABLE_EXECINFO
-#   include <eosio/check.hpp>
-#else
-#   include <stdexcept>
-#endif
-
-#include <outcome-basic.hpp>
-#include <system_error>
-
-namespace eosio {
-namespace outcome = OUTCOME_V2_NAMESPACE;
-
-template <typename T>
-using result = outcome::basic_result<T, std::error_code, outcome::policy::all_narrow>;
-
-#if defined(__eosio_cdt__)
-[[noreturn]] inline void check(std::error_code ec) {
-   check(false, ec.message());
-   __builtin_unreachable();
-}
-#else
-[[noreturn]] inline void check(std::error_code ec) { throw std::runtime_error(ec.message()); }
-#endif
-
-template <typename T>
-result<T> check(result<T> r) {
-   if (!r)
-      check(r.error());
-   return r;
-}
-
-template <typename T>
-void check_discard(result<T> r) {
-   if (!r)
-      check(r.error());
-}
-
-} // namespace eosio

package/include/eosio/fixed_bytes.hpp

@@ -1,250 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include "from_json.hpp"
-#include "operators.hpp"
-#include "reflection.hpp"
-#include "to_json.hpp"
-#include <type_traits>
-
-namespace eosio {
-
-/**
- *  @defgroup fixed_bytes Fixed Size Byte Array
- *  @ingroup core
- *  @ingroup types
- *  @brief Fixed size array of bytes sorted lexicographically
- */
-
-/**
- *  Fixed size byte array sorted lexicographically
- *
- *  @ingroup fixed_bytes
- *  @tparam Size - Size of the fixed_bytes object
- *  @tparam Word - Type to use for storage
- */
-template <std::size_t Size, typename Word = std::uint64_t>
-class fixed_bytes {
- private:
-   // Returns the minimum number of objects of type T required to hold at least Size bytes.
-   // T must be an unsigned integer type.
-   template <typename T>
-   static constexpr std::size_t count_words() {
-      return (Size + sizeof(T) - 1) / sizeof(T);
-   }
-   // Divides a value into words and writes the highest words first.
-   // If U is 1 byte, this is equivalent to big-endian encoding.
-   // sizeof(T) must be divisible by sizeof(U).
-   // Writes up to sizeof(T)/sizeof(U) elements to the range [ptr, end)
-   // Returns the end of the range written.
-   template <typename U, typename T>
-   static constexpr U* write_be(U* ptr, U* end, T t) {
-      constexpr std::size_t words = sizeof(T) / sizeof(U);
-      for (std::size_t i = 0; i < words && ptr < end; ++i) {
-         *ptr++ = static_cast<U>(t >> std::numeric_limits<U>::digits * (words - i - 1));
-      }
-      return ptr;
-   }
-   // The opposite of write_be.  If there are insufficient elements in [ptr, end),
-   // fills `out` as if the missing elements were 0.
-   template <typename U, typename T>
-   static constexpr const U* read_be(const U* ptr, const U* end, T& out) {
-      constexpr std::size_t words  = sizeof(T) / sizeof(U);
-      T                     result = 0;
-      for (std::size_t i = 0; i < words && ptr < end; ++i, ++ptr) {
-         result |= static_cast<T>(*ptr) << (std::numeric_limits<U>::digits * (words - i - 1));
-      }
-      out = result;
-      return ptr;
-   }
-   // Either splits or combines words depending on whether
-   // T is larger than U.
-   // Both arrays must hold the minimum number of elements
-   // required to store Size bytes.
-   template <typename T, typename U>
-   static constexpr void convert_array(const T* t, U* u) {
-      constexpr std::size_t t_elems = count_words<T>();
-      constexpr std::size_t u_elems = count_words<U>();
-      if constexpr (sizeof(T) > sizeof(U)) {
-         U* const end = u + u_elems;
-         for (std::size_t i = 0; i < t_elems; ++i) { u = write_be(u, end, t[i]); }
-      } else {
-         const T* const end = t + t_elems;
-         for (std::size_t i = 0; i < u_elems; ++i) { t = read_be(t, end, u[i]); }
-      }
-   }
-
-   template <typename T, typename U>
-   static constexpr std::array<T, count_words<T>()> convert_array(const U* u) {
-      std::array<T, count_words<T>()> result{0};
-      convert_array(u, result.data());
-      return result;
-   }
-
-   template <typename T, typename U>
-   static constexpr std::array<T, count_words<T>()> convert_array(const U* u, const U* end) {
-      std::array<U, count_words<U>()> tmp{0};
-      std::size_t                     count = std::min(static_cast<std::size_t>(end - u), tmp.size());
-      for (std::size_t i = 0; i < count; ++i) { tmp[i] = u[i]; }
-      return convert_array<T>(tmp.data());
-   }
-
-   template <typename T>
-   using require_word = std::enable_if_t<std::is_unsigned_v<T>>;
-
- public:
-   using word_t = Word;
-   /**
-    * Get number of words contained in this fixed_bytes object. A word is defined to be 16 bytes in size
-    */
-   static constexpr std::size_t num_words() { return count_words<Word>(); }
-
-   /**
-    * Get number of padded bytes contained in this fixed_bytes object. Padded bytes are the remaining bytes
-    * inside the fixed_bytes object after all the words are allocated
-    */
-   static constexpr size_t padded_bytes() { return num_words() * sizeof(Word) - Size; }
-
-   /**
-    * Default constructor to fixed_bytes object which initializes all bytes to zero
-    */
-   constexpr fixed_bytes() = default;
-
-   /**
-    * Constructor to fixed_bytes object from initializer list of bytes.
-    */
-   constexpr fixed_bytes(std::initializer_list<std::uint8_t> il) : value(convert_array<Word>(il.begin(), il.end())) {}
-
-   /**
-    * Constructor to fixed_bytes object from std::array of num_words() word_t types
-    *
-    * @param arr    data
-    */
-   constexpr fixed_bytes(const std::array<Word, num_words()>& arr) : value(arr) {}
-
-   /**
-    * Constructor to fixed_bytes object from std::array of unsigned integral types.
-    *
-    * @param arr - Source data.  arr cannot hold more words than are required to fill Size bytes.  If it contains
-    * fewer than Size bytes, the remaining bytes will be zero-filled.
-    */
-   template <typename T, std::size_t N,
-             typename Enable = std::enable_if_t<std::is_unsigned_v<T> && N <= count_words<T>()>>
-   constexpr fixed_bytes(const std::array<T, N>& arr) : value(convert_array<Word>(arr.begin(), arr.end())) {}
-
-   /**
-    * Constructor to fixed_bytes object from fixed-sized C array of unsigned integral types.
-    *
-    * @param arr - Source data.  arr cannot hold more words than are required to fill Size bytes.  If it contains
-    * fewer than Size bytes, the remaining bytes will be zero-filled.
-    */
-   template <typename T, std::size_t N,
-             typename Enable = std::enable_if_t<std::is_unsigned_v<T> && N <= count_words<T>()>>
-   constexpr fixed_bytes(const T (&arr)[N]) : value(convert_array<Word>(&arr[0], &arr[0] + N)) {}
-
-   /**
-    *  Create a new fixed_bytes object from a sequence of words
-    *
-    *  @tparam T - The type of the words.  T must be specified explicitly.
-    *  @param a - The words in the sequence.   All the parameters must have type T.  The number of parameters must
-    *             be equal to the number of values of type T required to fill Size bytes.
-    */
-   template <typename T, typename... A,
-             typename Enable = std::enable_if_t<(std::is_unsigned_v<T> && (std::is_same_v<T, A> && ...) &&
-                                                 (count_words<T>() == sizeof...(A)))>>
-   static constexpr fixed_bytes make_from_word_sequence(A... a) {
-      T args[count_words<T>()] = { a... };
-      return fixed_bytes(args);
-   }
-   /**
-    * Extract the contained data as an array of words
-    *
-    * @tparam T - The word type to return.  T must be an unsigned integral type.
-    */
-   template <typename T>
-   constexpr auto extract_as_word_array() const {
-      return convert_array<T>(data());
-   }
-   /**
-    * Extract the contained data as an array of bytes
-    *
-    * @return - the extracted data as array of bytes
-    */
-   constexpr std::array<std::uint8_t, Size> extract_as_byte_array() const {
-      return extract_as_word_array<std::uint8_t>();
-   }
-   /**
-    * Get the underlying data of the contained std::array
-    */
-   constexpr Word* data() { return value.data(); }
-   /**
-    * Get the underlying data of the contained std::array
-    */
-   constexpr const Word* data() const { return value.data(); }
-   constexpr std::size_t size() const { return value.size(); }
-   /**
-    * Get the Word storing capacity in the underlying data of the contained std::array
-    */
-   constexpr std::size_t capacity() const { return Size; }
-   /**
-    * Get the contained std::array
-    */
-   constexpr const auto&                 get_array() const { return value; }
-   std::array<Word, count_words<Word>()> value{0};
-};
-
-// This is only needed to make eosio.cdt/tests/unit/fixed_bytes_tests.cpp pass.
-// Everything else should be using one of the typedefs below.
-template <std::size_t Size, typename Word, typename F>
-void eosio_for_each_field(fixed_bytes<Size, Word>*, F&& f) {
-   f("value",
-     [](auto* p) -> decltype(&std::decay_t<decltype(*p)>::value) { return &std::decay_t<decltype(*p)>::value; });
-}
-
-template <std::size_t Size, typename Word>
-EOSIO_COMPARE(fixed_bytes<Size, Word>);
-
-using checksum160 = fixed_bytes<20,uint32_t>;
-using checksum256 = fixed_bytes<32>;
-using checksum512 = fixed_bytes<64>;
-
-EOSIO_REFLECT(checksum160, value);
-EOSIO_REFLECT(checksum256, value);
-EOSIO_REFLECT(checksum512, value);
-
-template <typename T, std::size_t Size, typename S>
-void from_bin(fixed_bytes<Size, T>& obj, S& stream) {
-   std::array<std::uint8_t, Size> bytes;
-   from_bin(bytes, stream);
-   obj = fixed_bytes<Size, T>(bytes);
-}
-
-template <typename T, std::size_t Size, typename S>
-void to_bin(const fixed_bytes<Size, T>& obj, S& stream) {
-   to_bin(obj.extract_as_byte_array(), stream);
-}
-
-template <typename T, std::size_t Size, typename S>
-void to_key(const fixed_bytes<Size, T>& obj, S& stream) {
-   to_bin(obj.extract_as_byte_array(), stream);
-}
-
-template <typename T, std::size_t Size, typename S>
-void from_json(fixed_bytes<Size, T>& obj, S& stream) {
-   std::vector<char> v;
-   eosio::from_json_hex(v, stream);
-   check(v.size() == Size, convert_json_error(eosio::from_json_error::hex_string_incorrect_length));
-   std::array<uint8_t, Size> bytes;
-   std::memcpy(bytes.data(), v.data(), Size);
-   obj = fixed_bytes<Size, T>(bytes);
-}
-
-template <typename T, std::size_t Size, typename S>
-void to_json(const fixed_bytes<Size, T>& obj, S& stream) {
-   auto bytes = obj.extract_as_byte_array();
-   eosio::to_json_hex((const char*)bytes.data(), bytes.size(), stream);
-}
-
-} // namespace eosio

package/include/eosio/float.hpp

@@ -1,35 +0,0 @@
-#pragma once
-
-#ifdef __eosio_cdt__
-
-namespace eosio {
-
-using float32  = float;
-using float64  = double;
-using float128 = long double;
-
-} // namespace eosio
-
-#else
-
-#   include <eosio/fixed_bytes.hpp>
-#   include <limits>
-
-namespace eosio {
-
-using float32  = float;
-using float64  = double;
-using float128 = fixed_bytes<16>;
-
-static_assert(sizeof(float32) == 4 && std::numeric_limits<float32>::is_iec559 &&
-                    std::numeric_limits<float32>::digits == 24,
-              "Unexpected float representation");
-static_assert(sizeof(float64) == 8 && std::numeric_limits<float64>::is_iec559 &&
-                    std::numeric_limits<float64>::digits == 53,
-              "Unexpected double representation");
-
-EOSIO_REFLECT(float128, value);
-
-} // namespace eosio
-
-#endif

package/include/eosio/for_each_field.hpp

@@ -1,48 +0,0 @@
-#pragma once
-
-#include "reflection.hpp"
-#include <utility>
-
-#if __has_include(<boost/pfr/precise/core.hpp>)
-
-#   include <boost/pfr/precise/core.hpp>
-
-namespace eosio {
-template <typename T, typename F>
-constexpr auto for_each_field(T&& t, F&& f) -> std::enable_if_t<!reflection::has_for_each_field_v<std::decay_t<T>>> {
-   return boost::pfr::for_each_field(static_cast<T&&>(t), static_cast<F&&>(f));
-}
-} // namespace eosio
-#endif
-
-namespace eosio {
-
-template <typename T, typename F>
-constexpr auto for_each_field(T&& t, F&& f) -> std::enable_if_t<reflection::has_for_each_field_v<std::decay_t<T>>> {
-   eosio_for_each_field((std::decay_t<T>*)nullptr, [&](const char*, auto member) {
-      if constexpr (std::is_member_object_pointer_v<decltype(member(&t))>) {
-         f(t.*member(&t));
-      }
-   });
-}
-
-template <typename T, typename F>
-constexpr void for_each_field(F&& f) {
-   eosio_for_each_field((T*)nullptr, [&f](const char* name, auto member) {
-      if constexpr (std::is_member_object_pointer_v<decltype(member((T*)nullptr))>) {
-         f(name, [member](auto p) -> decltype((p->*member(p))) { return p->*member(p); });
-      }
-   });
-}
-
-// Calls f(#fn_name, &T::fn_name) for every reflected member function of T.
-template <typename T, typename F>
-constexpr void for_each_method(F&& f) {
-   eosio_for_each_field((T*)nullptr, [&f](const char* name, auto member) {
-      if constexpr (std::is_member_function_pointer_v<decltype(member((T*)nullptr))>) {
-         f(name, member((T*)nullptr));
-      }
-   });
-}
-
-} // namespace eosio