CMakeLists.txt

@@ -208,6 +208,7 @@ set( fc_sources
      src/crypto/hex.cpp
      src/crypto/sha1.cpp
      src/crypto/ripemd160.cpp
+     src/crypto/hash160.cpp
      src/crypto/sha256.cpp
      src/crypto/sha224.cpp
      src/crypto/sha512.cpp

include/fc/crypto/hash160.hpp

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2018 jmjatlanta and contributors.
+ *
+ * The MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#pragma once
+#include <boost/endian/buffers.hpp>
+#include <fc/fwd.hpp>
+#include <fc/string.hpp>
+#include <fc/io/raw_fwd.hpp>
+
+namespace fc{
+
+class hash160
+{
+   public:
+   hash160();
+   explicit hash160( const string& hex_str );
+
+   string str()const;
+   explicit operator string()const;
+
+   char* data() const;
+   static constexpr size_t data_size() { return 160/8; }
+
+   static hash160 hash( const char* d, uint32_t dlen );
+   static hash160 hash( const string& );
+
+   template<typename T>
+   static hash160 hash( const T& t ) 
+   { 
+      hash160::encoder e; 
+      fc::raw::pack(e,t);
+      return e.result(); 
+   } 
+
+   class encoder 
+   {
+      public:
+      encoder();
+      ~encoder();
+
+      void write( const char* d, uint32_t dlen );
+      void put( char c ) { write( &c, 1 ); }
+      void reset();
+      hash160 result();
+
+      private:
+      class impl;
+      fc::fwd<impl,117> my;
+   };
+
+   template<typename T>
+   inline friend T& operator<<( T& ds, const hash160& ep ) {
+      ds.write( ep.data(), sizeof(ep) );
+      return ds;
+   }
+
+   template<typename T>
+   inline friend T& operator>>( T& ds, hash160& ep ) {
+      ds.read( ep.data(), sizeof(ep) );
+      return ds;
+   }
+   friend hash160 operator << ( const hash160& h1, uint32_t i       );
+   friend bool operator == ( const hash160& h1, const hash160& h2 );
+   friend bool operator != ( const hash160& h1, const hash160& h2 );
+   friend hash160 operator ^  ( const hash160& h1, const hash160& h2 );
+   friend bool operator >= ( const hash160& h1, const hash160& h2 );
+   friend bool operator >  ( const hash160& h1, const hash160& h2 );
+   friend bool operator <  ( const hash160& h1, const hash160& h2 );
+
+   boost::endian::little_uint32_buf_t _hash[5];
+};
+
+namespace raw {
+
+   template<typename T>
+   inline void pack( T& ds, const hash160& ep, uint32_t _max_depth ) {
+      ds << ep;
+   }
+
+   template<typename T>
+   inline void unpack( T& ds, hash160& ep, uint32_t _max_depth ) {
+      ds >> ep;
+   }
+
+}
+
+   class variant;
+   void to_variant( const hash160& bi, variant& v, uint32_t max_depth );
+   void from_variant( const variant& v, hash160& bi, uint32_t max_depth );
+
+  template<> struct get_typename<hash160>    { static const char* name()  { return "hash160";  } };
+} // namespace fc
+
+namespace std
+{
+   template<>
+   struct hash<fc::hash160>
+   {
+      size_t operator()( const fc::hash160& s )const
+      {
+         return  *((size_t*)&s);
+      }
+   };
+}

include/fc/io/raw.hpp

@@ -307,7 +307,7 @@ namespace fc {
     template<typename Stream> inline void pack( Stream& s, const bool& v, uint32_t _max_depth )
     {
        FC_ASSERT( _max_depth > 0 );
-       fc::raw::pack( s, uint8_t(v), _max_depth - 1 );
+       fc::raw::pack( s, v ? uint8_t(1) : uint8_t(0), _max_depth - 1 );
     }
     template<typename Stream> inline void unpack( Stream& s, bool& v, uint32_t _max_depth )
     {

include/fc/static_variant.hpp

@@ -75,7 +75,7 @@ protected:
     void init_from_tag(tag_type tag)
     {
         FC_ASSERT( tag >= 0 );
-        FC_ASSERT( tag < count() );
+        FC_ASSERT( static_cast<size_t>(tag) < count() );
         _tag = tag;
         typelist::runtime::dispatch(list(), tag, [this](auto t) {
             using T = typename decltype(t)::type;
@@ -118,7 +118,7 @@ public:
     template<typename X, typename = type_in_typelist<X>>
     struct tag
     {
-       static constexpr int value = typelist::index_of<list, X>();
+       static constexpr tag_type value = typelist::index_of<list, X>();
     };
 
     struct type_lt {
@@ -269,7 +269,7 @@ public:
     template<typename visitor>
     static typename visitor::result_type visit( tag_type tag, visitor& v, void* data )
     {
-        FC_ASSERT( tag >= 0 && tag < count(), "Unsupported type ${tag}!", ("tag",tag) );
+        FC_ASSERT( tag >= 0 && static_cast<size_t>(tag) < count(), "Unsupported type ${tag}!", ("tag",tag) );
         return typelist::runtime::dispatch(list(), tag, [&v, data](auto t) {
             return v(*reinterpret_cast<typename decltype(t)::type*>(data));
         });
@@ -278,7 +278,7 @@ public:
     template<typename visitor>
     static typename visitor::result_type visit( tag_type tag, const visitor& v, void* data )
     {
-        FC_ASSERT( tag >= 0 && tag < count(), "Unsupported type ${tag}!", ("tag",tag) );
+        FC_ASSERT( tag >= 0 && static_cast<size_t>(tag) < count(), "Unsupported type ${tag}!", ("tag",tag) );
         return typelist::runtime::dispatch(list(), tag, [&v, data](auto t) {
             return v(*reinterpret_cast<typename decltype(t)::type*>(data));
         });
@@ -287,7 +287,7 @@ public:
     template<typename visitor>
     static typename visitor::result_type visit( tag_type tag, visitor& v, const void* data )
     {
-        FC_ASSERT( tag >= 0 && tag < count(), "Unsupported type ${tag}!", ("tag",tag) );
+        FC_ASSERT( tag >= 0 && static_cast<size_t>(tag) < count(), "Unsupported type ${tag}!", ("tag",tag) );
         return typelist::runtime::dispatch(list(), tag, [&v, data](auto t) {
             return v(*reinterpret_cast<const typename decltype(t)::type*>(data));
         });
@@ -296,18 +296,18 @@ public:
     template<typename visitor>
     static typename visitor::result_type visit( tag_type tag, const visitor& v, const void* data )
     {
-        FC_ASSERT( tag >= 0 && tag < count(), "Unsupported type ${tag}!", ("tag",tag) );
+        FC_ASSERT( tag >= 0 && static_cast<size_t>(tag) < count(), "Unsupported type ${tag}!", ("tag",tag) );
         return typelist::runtime::dispatch(list(), tag, [&v, data](auto t) {
             return v(*reinterpret_cast<const typename decltype(t)::type*>(data));
         });
     }
 
-    static constexpr int count() { return typelist::length<list>(); }
-    void set_which( tag_type w ) {
-      FC_ASSERT( w >= 0 );
-      FC_ASSERT( w < count() );
+    static constexpr size_t count() { return typelist::length<list>(); }
+    void set_which( tag_type tag ) {
+      FC_ASSERT( tag >= 0 );
+      FC_ASSERT( static_cast<size_t>(tag) < count() );
       clean();
-      init_from_tag(w);
+      init_from_tag(tag);
     }
 
     tag_type which() const {return _tag;}

include/fc/variant.hpp

@@ -581,9 +581,7 @@ namespace fc
       memset( this, 0, sizeof(*this) );
       to_variant( val, *this, max_depth );
    }
-   #ifdef __APPLE__
-   inline void to_variant( size_t s, variant& v, uint32_t max_depth ) { v = variant(uint64_t(s)); }
-   #endif
+
    template<typename T>
    void to_variant( const std::shared_ptr<T>& var, variant& vo, uint32_t max_depth )
    {

src/crypto/hash160.cpp

@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2018 jmjatlanta and contributors.
+ *
+ * The MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <fc/crypto/hex.hpp>
+#include <fc/crypto/hmac.hpp>
+#include <fc/fwd_impl.hpp>
+#include <openssl/sha.h>
+#include <openssl/ripemd.h>
+#include <string.h>
+#include <cmath>
+#include <fc/crypto/hash160.hpp>
+#include <fc/variant.hpp>
+#include <fc/exception/exception.hpp>
+#include "_digest_common.hpp"
+
+namespace fc 
+{
+  
+hash160::hash160() { memset( _hash, 0, sizeof(_hash) ); }
+
+hash160::hash160( const string& hex_str ) {
+   fc::from_hex( hex_str, (char*)_hash, sizeof(_hash) );  
+}
+
+string hash160::str()const {
+   return fc::to_hex( (char*)_hash, sizeof(_hash) );
+}
+
+hash160::operator string()const { return  str(); }
+
+char* hash160::data()const { return (char*)&_hash[0]; }
+
+struct hash160::encoder::impl {
+   SHA256_CTX ctx;
+};
+
+hash160::encoder::~encoder() {}
+hash160::encoder::encoder() { SHA256_Init(&my->ctx); }
+
+hash160 hash160::hash( const char* d, uint32_t dlen ) {
+   encoder e;
+   e.write(d,dlen);
+   return e.result();
+}
+
+hash160 hash160::hash( const string& s ) {
+   return hash( s.c_str(), s.size() );
+}
+
+void hash160::encoder::write( const char* d, uint32_t dlen )
+{
+   SHA256_Update( &my->ctx, d, dlen); 
+}
+
+hash160 hash160::encoder::result() {
+   // finalize the first hash
+   unsigned char sha_hash[SHA256_DIGEST_LENGTH];
+   SHA256_Final( sha_hash, &my->ctx );
+   // perform the second hashing function
+   RIPEMD160_CTX ripe_ctx;
+   RIPEMD160_Init(&ripe_ctx);
+   RIPEMD160_Update( &ripe_ctx, sha_hash, SHA256_DIGEST_LENGTH );
+   hash160 h;
+   RIPEMD160_Final( (uint8_t *)h.data(), &ripe_ctx );
+   return h;
+}
+
+void hash160::encoder::reset() 
+{
+   SHA256_Init(&my->ctx);
+}
+
+hash160 operator << ( const hash160& h1, uint32_t i ) {
+   hash160 result;
+   fc::detail::shift_l( h1.data(), result.data(), result.data_size(), i );
+   return result;
+}
+
+hash160 operator ^ ( const hash160& h1, const hash160& h2 ) {
+   hash160 result;
+   result._hash[0] = h1._hash[0].value() ^ h2._hash[0].value();
+   result._hash[1] = h1._hash[1].value() ^ h2._hash[1].value();
+   result._hash[2] = h1._hash[2].value() ^ h2._hash[2].value();
+   result._hash[3] = h1._hash[3].value() ^ h2._hash[3].value();
+   result._hash[4] = h1._hash[4].value() ^ h2._hash[4].value();
+   return result;
+}
+
+bool operator >= ( const hash160& h1, const hash160& h2 ) {
+   return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) >= 0;
+}
+
+bool operator > ( const hash160& h1, const hash160& h2 ) {
+   return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) > 0;
+}
+
+bool operator < ( const hash160& h1, const hash160& h2 ) {
+   return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) < 0;
+}
+
+bool operator != ( const hash160& h1, const hash160& h2 ) {
+   return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) != 0;
+}
+
+bool operator == ( const hash160& h1, const hash160& h2 ) {
+   return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) == 0;
+}
+  
+void to_variant( const hash160& bi, variant& v, uint32_t max_depth )
+{
+   to_variant( std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) ), v, max_depth );
+}
+
+void from_variant( const variant& v, hash160& bi, uint32_t max_depth )
+{
+   std::vector<char> ve = v.as< std::vector<char> >( max_depth );
+   memset( &bi, char(0), sizeof(bi) );
+   if( ve.size() )
+      memcpy( &bi, ve.data(), std::min<size_t>(ve.size(),sizeof(bi)) );
+}
+  
+} // fc

src/exception.cpp

@@ -205,12 +205,12 @@ namespace fc
                   ss << "ERROR: Failed to convert log data to string!\n";
                }
                ss << "    " << itr->get_context().to_string();
-               ++itr;
             } catch( std::bad_alloc& ) {
                throw;
             } catch( ... ) {
                ss << "<- exception in to_detail_string.";
             }
+            ++itr;
             if( itr != my->_elog.end() ) ss<<"\n";
          }
       } catch( std::bad_alloc& ) {

src/variant.cpp

@@ -701,9 +701,8 @@ void from_variant( const variant& var, uint128_t& vo, uint32_t max_depth )
 #endif
 }
 
-#if defined(__APPLE__)
-#elif defined(__OpenBSD__)
-   void to_variant( size_t s, variant& v, uint32_t max_depth ) { v = variant( int64_t(s) ); }
+#if defined(__APPLE__) or defined(__OpenBSD__)
+   void to_variant( size_t s, variant& v, uint32_t max_depth ) { v = variant( uint64_t(s) ); }
 #elif !defined(_WIN32)
    void to_variant( long long int s, variant& v, uint32_t max_depth ) { v = variant( int64_t(s) ); }
    void to_variant( unsigned long long int s, variant& v, uint32_t max_depth ) { v = variant( uint64_t(s)); }

tests/crypto/sha_tests.cpp

@@ -2,6 +2,7 @@
 
 #include <fc/crypto/digest.hpp>
 #include <fc/crypto/ripemd160.hpp>
+#include <fc/crypto/hash160.hpp>
 #include <fc/crypto/sha1.hpp>
 #include <fc/crypto/sha224.hpp>
 #include <fc/crypto/sha256.hpp>
@@ -108,6 +109,18 @@ BOOST_AUTO_TEST_CASE(ripemd160_test)
     test_stream<fc::ripemd160>();
 }
 
+BOOST_AUTO_TEST_CASE( hash160_test )
+{
+   
+   test<fc::hash160>( TEST1, "bb1be98c142444d7a56aa3981c3942a978e4dc33" );
+   test<fc::hash160>( TEST2, "b472a266d0bd89c13706a4132ccfb16f7c3b9fcb" );
+   test<fc::hash160>( TEST3, "69dda8a60e0cfc2353aa776864092c0e5ccb4834" );
+   test<fc::hash160>( TEST4, "dfcc6db6ea54d85d2e3a76573183f7a037a729b0" );
+   init_5();
+   test<fc::hash160>( TEST5, "f9be0e104ef2ed83a7ddb4765780951405e56ba4" ); 
+   test<fc::hash160>( TEST6, "3eca00d3b1fcafb0b74fa07fe890bea9b053a17e" );
+}
+
 BOOST_AUTO_TEST_CASE(sha1_test)
 {
     init_5();

tests/stacktrace_test.cpp

@@ -74,8 +74,10 @@ BOOST_AUTO_TEST_CASE(static_variant_depth_test)
    int count = 0;
    for( const auto& line : lines )
       if( line.find("_svdt_visitor") != std::string::npos ) count++;
-   BOOST_CHECK_LT( 1, count );  // The actual count depends on compiler and optimization settings.
+   BOOST_CHECK_LT( 1, count ); // test.visit(), static_variant::visit, function object, visitor.
+                               // The actual count depends on compiler and optimization settings.
    BOOST_CHECK_GT( 10, count ); // It *should* be less than the number of static variant components.
+                                // some is implementation-dependent
 }
 #endif