Update master

.gitmodules

@@ -1,6 +1,6 @@
-[submodule "secp256k1/upstream"]
-	path = secp256k1/upstream
-	url = https://github.com/cryptonomex/secp256k1-zkp.git
 [submodule "include/fc/crypto/webauthn_json"]
 	path = include/fc/crypto/webauthn_json
 	url = https://github.com/Tencent/rapidjson/
+[submodule "secp256k1/secp256k1"]
+	path = secp256k1/secp256k1
+	url = https://github.com/bitcoin-core/secp256k1

CMakeLists.txt

@@ -25,7 +25,10 @@ elseif(NOT CMAKE_CXX_STANDARD)
    set(CMAKE_CXX_STANDARD_REQUIRED ON)
 endif()
 
+# Suppress warnings on 3rdParty Library
+add_definitions( -w )
 add_subdirectory( secp256k1 )
+remove_definitions( -w )
 
 IF( ECC_IMPL STREQUAL openssl )
   SET( ECC_REST src/crypto/elliptic_impl_pub.cpp )
@@ -72,8 +75,7 @@ set( fc_sources
      src/log/log_message.cpp
      src/log/logger.cpp
      src/log/appender.cpp
-     src/log/console_appender.cpp
-     src/log/gelf_appender.cpp
+     src/log/console_appender.cpp    
      src/log/dmlog_appender.cpp
      src/log/logger_config.cpp
      src/crypto/_digest_common.cpp
@@ -111,6 +113,8 @@ set( fc_sources
      src/network/http/http_client.cpp
      src/compress/smaz.cpp
      src/compress/zlib.cpp
+     src/log/gelf_appender.cpp
+     src/log/zipkin.cpp
      )
 
 file( GLOB_RECURSE fc_headers ${CMAKE_CURRENT_SOURCE_DIR} *.hpp *.h )

CMakeModules/FindGMP.cmake

@@ -1,3 +1,5 @@
+# This module's inputs:
+#  GMP_STATIC            - static link GMP
 # This module defines:
 #  GMP_FOUND             - system has GMP lib
 #  GMP_INCLUDE_DIR       - the GMP include directory
@@ -32,7 +34,11 @@ else()
            )
 
   set(PREVIOUS_CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_FIND_LIBRARY_SUFFIXES}")
-  set(CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_SHARED_LIBRARY_SUFFIX}")
+  if(GMP_STATIC)
+    set(CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_STATIC_LIBRARY_SUFFIX}")
+  else()
+    set(CMAKE_FIND_LIBRARY_SUFFIXES "${CMAKE_SHARED_LIBRARY_SUFFIX}")
+  endif()
 
   find_library(GMP_LIBRARIES NAMES gmp
     HINTS ENV GMP_LIB_DIR

include/fc/array.hpp

@@ -116,7 +116,7 @@ namespace fc {
         memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );
     }
     else
-        memset( &bi, char(0), sizeof(bi) );
+        memset( bi.data, char(0), sizeof(bi.data) );
   }
 
 

include/fc/crypto/common.hpp

@@ -72,16 +72,16 @@ namespace fc { namespace crypto {
     * @return
     */
    template<const char * const * Prefixes, typename ...Ts>
-   struct base58_str_parser<fc::static_variant<Ts...>, Prefixes> {
-      static fc::static_variant<Ts...> apply(const std::string& base58str) {
+   struct base58_str_parser<std::variant<Ts...>, Prefixes> {
+      static std::variant<Ts...> apply(const std::string& base58str) {
          const auto pivot = base58str.find('_');
          FC_ASSERT(pivot != std::string::npos, "No delimiter in data, cannot determine suite type: ${str}", ("str", base58str));
 
          const auto prefix_str = base58str.substr(0, pivot);
          auto data_str = base58str.substr(pivot + 1);
          FC_ASSERT(!data_str.empty(), "Data only has suite type prefix: ${str}", ("str", base58str));
 
-         return base58_str_parser_impl<fc::static_variant<Ts...>, Prefixes, 0, Ts...>::apply(prefix_str, data_str);
+         return base58_str_parser_impl<std::variant<Ts...>, Prefixes, 0, Ts...>::apply(prefix_str, data_str);
       }
    };
 
@@ -92,7 +92,7 @@ namespace fc { namespace crypto {
       template< typename KeyType >
       std::string operator()( const KeyType& key ) const {
          using data_type = typename KeyType::data_type;
-         constexpr int position = Storage::template position<KeyType>();
+         constexpr int position = fc::get_index<Storage, KeyType>();
          constexpr bool is_default = position == DefaultPosition;
 
          checksummed_data<data_type> wrapper;
@@ -122,23 +122,23 @@ namespace fc { namespace crypto {
    };
 
    template<typename ... Ts>
-   struct eq_comparator<fc::static_variant<Ts...>> {
-      using variant_type = fc::static_variant<Ts...>;
+   struct eq_comparator<std::variant<Ts...>> {
+      using variant_type = std::variant<Ts...>;
       struct visitor : public fc::visitor<bool> {
          visitor(const variant_type &b)
             : _b(b) {}
 
          template<typename KeyType>
          bool operator()(const KeyType &a) const {
-            const auto &b = _b.template get<KeyType>();
+            const auto &b = std::template get<KeyType>(_b);
             return eq_comparator<KeyType>::apply(a,b);
          }
 
          const variant_type &_b;
       };
 
       static bool apply(const variant_type& a, const variant_type& b) {
-         return a.which() == b.which() && a.visit(visitor(b));
+         return a.index() == b.index() && std::visit(visitor(b), a);
       }
    };
 
@@ -150,23 +150,23 @@ namespace fc { namespace crypto {
    };
 
    template<typename ... Ts>
-   struct less_comparator<fc::static_variant<Ts...>> {
-      using variant_type = fc::static_variant<Ts...>;
+   struct less_comparator<std::variant<Ts...>> {
+      using variant_type = std::variant<Ts...>;
       struct visitor : public fc::visitor<bool> {
          visitor(const variant_type &b)
             : _b(b) {}
 
          template<typename KeyType>
          bool operator()(const KeyType &a) const {
-            const auto &b = _b.template get<KeyType>();
+            const auto &b = std::template get<KeyType>(_b);
             return less_comparator<KeyType>::apply(a,b);
          }
 
          const variant_type &_b;
       };
 
       static bool apply(const variant_type& a, const variant_type& b) {
-         return a.which() < b.which() || (a.which() == b.which() && a.visit(visitor(b)));
+         return a.index() < b.index() || (a.index() == b.index() && std::visit(visitor(b), a));
       }
    };
 

include/fc/crypto/elliptic.hpp

@@ -24,7 +24,6 @@ namespace fc {
     typedef fc::array<char,65>          public_key_point_data; ///< the full non-compressed version of the ECC point
     typedef fc::array<char,72>          signature;
     typedef fc::array<unsigned char,65> compact_signature;
-    typedef std::vector<char>           range_proof_type;
     typedef fc::array<char,78>          extended_key_data;
     typedef fc::sha256                  blinded_hash;
     typedef fc::sha256                  blind_signature;
@@ -53,11 +52,6 @@ namespace fc {
            public_key child( const fc::sha256& offset )const;
 
            bool valid()const;
-           /** Computes new pubkey = generator * offset + old pubkey ?! */
-//           public_key mult( const fc::sha256& offset )const;
-           /** Computes new pubkey = regenerate(offset).pubkey + old pubkey
-            *                      = offset * G + 1 * old pubkey ?! */
-           public_key add( const fc::sha256& offset )const;
 
            public_key( public_key&& pk );
            public_key& operator=( public_key&& pk );
@@ -150,39 +144,6 @@ namespace fc {
            fc::fwd<detail::private_key_impl,32> my;
     };
 
-     struct range_proof_info
-     {
-         int          exp;
-         int          mantissa;
-         uint64_t     min_value;
-         uint64_t     max_value;
-     };
-
-     commitment_type   blind( const blind_factor_type& blind, uint64_t value );
-     blind_factor_type blind_sum( const std::vector<blind_factor_type>& blinds, uint32_t non_neg );
-     /**  verifies taht commnits + neg_commits + excess == 0 */
-     bool            verify_sum( const std::vector<commitment_type>& commits, const std::vector<commitment_type>& neg_commits, int64_t excess );
-     bool            verify_range( uint64_t& min_val, uint64_t& max_val, const commitment_type& commit, const range_proof_type& proof );
-
-     range_proof_type range_proof_sign( uint64_t min_value,
-                                       const commitment_type& commit,
-                                       const blind_factor_type& commit_blind,
-                                       const blind_factor_type& nonce,
-                                       int8_t base10_exp,
-                                       uint8_t min_bits,
-                                       uint64_t actual_value
-                                     );
-
-     bool            verify_range_proof_rewind( blind_factor_type& blind_out,
-                                          uint64_t& value_out,
-                                          string& message_out,
-                                          const blind_factor_type& nonce,
-                                          uint64_t& min_val,
-                                          uint64_t& max_val,
-                                          commitment_type commit,
-                                          const range_proof_type& proof );
-     range_proof_info range_get_info( const range_proof_type& proof );
-
       /**
        * Shims
        */
@@ -273,7 +234,6 @@ namespace fc {
 
 FC_REFLECT_TYPENAME( fc::ecc::private_key )
 FC_REFLECT_TYPENAME( fc::ecc::public_key )
-FC_REFLECT( fc::ecc::range_proof_info, (exp)(mantissa)(min_value)(max_value) )
 FC_REFLECT_DERIVED( fc::ecc::public_key_shim, (fc::crypto::shim<fc::ecc::public_key_data>), BOOST_PP_SEQ_NIL )
 FC_REFLECT_DERIVED( fc::ecc::signature_shim, (fc::crypto::shim<fc::ecc::compact_signature>), BOOST_PP_SEQ_NIL )
 FC_REFLECT_DERIVED( fc::ecc::private_key_shim, (fc::crypto::shim<fc::ecc::private_key_secret>), BOOST_PP_SEQ_NIL )

include/fc/crypto/elliptic_r1.hpp

@@ -37,7 +37,6 @@ namespace fc {
            ~public_key();
            bool verify( const fc::sha256& digest, const signature& sig );
            public_key_data serialize()const;
-           public_key_point_data serialize_ecc_point()const;
 
            operator public_key_data()const { return serialize(); }
 

include/fc/crypto/private_key.hpp

@@ -19,7 +19,7 @@ namespace fc { namespace crypto {
    class private_key
    {
       public:
-         using storage_type = static_variant<ecc::private_key_shim, r1::private_key_shim>;
+         using storage_type = std::variant<ecc::private_key_shim, r1::private_key_shim>;
 
          private_key() = default;
          private_key( private_key&& ) = default;

include/fc/crypto/public_key.hpp

@@ -21,7 +21,7 @@ namespace fc { namespace crypto {
    class public_key
    {
       public:
-         using storage_type = static_variant<ecc::public_key_shim, r1::public_key_shim, webauthn::public_key>;
+         using storage_type = std::variant<ecc::public_key_shim, r1::public_key_shim, webauthn::public_key>;
 
          public_key() = default;
          public_key( public_key&& ) = default;

include/fc/crypto/sha1.hpp

@@ -13,7 +13,8 @@ class sha1
     string str()const;
     operator string()const;
 
-    char*    data()const;
+    char*       data();
+    const char* data()const;
     size_t data_size()const { return 20; }
 
     static sha1 hash( const char* d, uint32_t dlen );

include/fc/crypto/sha224.hpp

@@ -16,7 +16,8 @@ class sha224
     string str()const;
     operator string()const;
 
-    char*    data()const;
+    char*       data();
+    const char* data()const;
     size_t data_size()const { return 224 / 8; }
 
     static sha224 hash( const char* d, uint32_t dlen );

include/fc/crypto/sha256.hpp

@@ -4,6 +4,8 @@
 #include <fc/platform_independence.hpp>
 #include <fc/io/raw_fwd.hpp>
 
+#include <boost/container_hash/hash.hpp>
+
 namespace fc
 {
 
@@ -17,8 +19,9 @@ class sha256
     string str()const;
     operator string()const;
 
-    char*    data()const;
-    size_t data_size()const { return 256 / 8; }
+    const char* data()const;
+    char*       data();
+    size_t      data_size() const { return 256 / 8; }
 
     static sha256 hash( const char* d, uint32_t dlen );
     static sha256 hash( const string& );

include/fc/crypto/sha512.hpp

@@ -14,7 +14,8 @@ class sha512
     string str()const;
     operator string()const;
 
-    char*    data()const;
+    char*       data();
+    const char* data()const;
     size_t data_size()const { return 512 / 8; }
 
     static sha512 hash( const char* d, uint32_t dlen );

include/fc/crypto/signature.hpp

@@ -19,7 +19,7 @@ namespace fc { namespace crypto {
    class signature
    {
       public:
-         using storage_type = static_variant<ecc::signature_shim, r1::signature_shim, webauthn::signature>;
+         using storage_type = std::variant<ecc::signature_shim, r1::signature_shim, webauthn::signature>;
 
          signature() = default;
          signature( signature&& ) = default;

include/fc/exception/exception.hpp

@@ -4,7 +4,6 @@
  *  @brief Defines exception's used by fc
  */
 #include <fc/log/logger.hpp>
-#include <fc/optional.hpp>
 #include <exception>
 #include <functional>
 #include <unordered_map>
@@ -55,7 +54,7 @@ namespace fc
     *  @see FC_RETHROW_EXCEPTION
     *  @see FC_RETHROW_EXCEPTIONS
     */
-   class exception
+   class exception : public std::exception
    {
       public:
          static constexpr fc::microseconds format_time_limit = fc::milliseconds( 10 ); // limit time spent formatting exceptions
@@ -84,7 +83,7 @@ namespace fc
 
          const char*          name()const throw();
          int64_t              code()const throw();
-         virtual const char*  what()const throw();
+         const char*          what()const noexcept override;
 
          /**
           *   @return a reference to log messages that have
@@ -139,7 +138,7 @@ namespace fc
    void from_variant( const variant& e, exception& ll );
    typedef std::shared_ptr<exception> exception_ptr;
 
-   typedef optional<exception> oexception;
+   typedef std::optional<exception> oexception;
 
 
    /**
@@ -187,6 +186,8 @@ namespace fc
 
        std::exception_ptr get_inner_exception()const;
 
+       static std_exception_wrapper from_current_exception(const std::exception& e);
+
        virtual NO_RETURN void               dynamic_rethrow_exception()const;
        virtual std::shared_ptr<exception>   dynamic_copy_exception()const;
       private:
@@ -476,10 +477,8 @@ namespace fc
       wdump( __VA_ARGS__ ); \
    }
 
-#define FC_LOG_AND_DROP( ... )  \
-   catch( const boost::interprocess::bad_alloc& ) {\
-      throw;\
-   } catch( fc::exception& er ) { \
+#define FC_LOG_AND_DROP_ALL( ... )  \
+   catch( fc::exception& er ) { \
       wlog( "${details}", ("details",er.to_detail_string()) ); \
    } catch( const std::exception& e ) {  \
       fc::std_exception_wrapper sew( \
@@ -496,6 +495,12 @@ namespace fc
    }
 
 
+#define FC_LOG_AND_DROP( ... )  \
+   catch( const boost::interprocess::bad_alloc& ) {\
+      throw;\
+   } FC_LOG_AND_DROP_ALL(__VA_ARGS__)
+
+
 /**
  *  @def FC_RETHROW_EXCEPTIONS(LOG_LEVEL,FORMAT,...)
  *  @brief  Catchs all exception's, std::exceptions, and ... and rethrows them after