diff --git a/include/fc/variant.hpp b/include/fc/variant.hpp
index 848cb6a..973d762 100644
--- a/include/fc/variant.hpp
+++ b/include/fc/variant.hpp
@@ -31,14 +31,20 @@ namespace fc
    class time_point_sec;
    class microseconds;
 
-   void to_variant( const int16_t& var,  variant& vo );
-   void from_variant( const variant& var,  int16_t& vo );
-   void to_variant( const uint16_t& var,  variant& vo );
-   void from_variant( const variant& var,  uint16_t& vo );
-   void to_variant( const uint32_t& var,  variant& vo );
-   void from_variant( const variant& var,  uint32_t& vo );
    void to_variant( const uint8_t& var,  variant& vo );
    void from_variant( const variant& var,  uint8_t& vo );
+   void to_variant( const int8_t& var,  variant& vo );
+   void from_variant( const variant& var,  int8_t& vo );
+
+   void to_variant( const uint16_t& var,  variant& vo );
+   void from_variant( const variant& var,  uint16_t& vo );
+   void to_variant( const int16_t& var,  variant& vo );
+   void from_variant( const variant& var,  int16_t& vo );
+
+   void to_variant( const uint32_t& var,  variant& vo );
+   void from_variant( const variant& var,  uint32_t& vo );
+   void to_variant( const int32_t& var,  variant& vo );
+   void from_variant( const variant& var,  int32_t& vo );
 
    void to_variant( const variant_object& var,  variant& vo );
    void from_variant( const variant& var,  variant_object& vo );
@@ -94,7 +100,6 @@ namespace fc
    template<typename A, typename B>
    void from_variant( const variant& v, std::pair<A,B>& p );
 
-
    /**
     * @brief stores null, int64, uint64, double, bool, string, std::vector<variant>,
     *        and variant_object's.  
@@ -129,11 +134,15 @@ namespace fc
         variant( char* str );
         variant( wchar_t* str );
         variant( const wchar_t* str );
-        variant( int val );
         variant( float val );
+        variant( uint8_t val );
+        variant( int8_t val );
+        variant( uint16_t val );
+        variant( int16_t val );
         variant( uint32_t val );
-        variant( int64_t val );
+        variant( int32_t val );
         variant( uint64_t val );
+        variant( int64_t val );
         variant( double val );
         variant( bool val );
         variant( fc::string val );
diff --git a/src/variant.cpp b/src/variant.cpp
index 5ef005d..938c0c5 100644
--- a/src/variant.cpp
+++ b/src/variant.cpp
@@ -12,34 +12,6 @@
 
 namespace fc
 {
-
-   void to_variant( const uint16_t& var,  variant& vo )  { vo = uint64_t(var); }
-   // TODO: warn on overflow?
-   void from_variant( const variant& var,  uint16_t& vo ){ vo = static_cast<uint16_t>(var.as_uint64()); }
-
-   void to_variant( const int16_t& var,  variant& vo )  { vo = int64_t(var); }
-   // TODO: warn on overflow?
-   void from_variant( const variant& var,  int16_t& vo ){ vo = static_cast<int16_t>(var.as_int64()); }
-
-void to_variant( const std::vector<char>& var,  variant& vo )
-{
-  if( var.size() )
-      //vo = variant(base64_encode((unsigned char*)var.data(),var.size()));
-      vo = variant(to_hex(var.data(),var.size()));
-  else vo = "";
-}
-void from_variant( const variant& var,  std::vector<char>& vo )
-{
-     auto str = var.as_string();
-     vo.resize( str.size() / 2 );
-     if( vo.size() )
-     {
-        size_t r = from_hex( str, vo.data(), vo.size() );
-        FC_ASSERT( r = vo.size() );
-     }
-//   std::string b64 = base64_decode( var.as_string() );
-//   vo = std::vector<char>( b64.c_str(), b64.c_str() + b64.size() );
-}
 /**
  *  The TypeID is stored in the 'last byte' of the variant.
  */
@@ -59,35 +31,60 @@ variant::variant( fc::nullptr_t )
    set_variant_type( this, null_type );
 }
 
-variant::variant( uint32_t val )
+variant::variant( uint8_t val )
+{
+   *reinterpret_cast<uint64_t*>(this)  = val;
+   set_variant_type( this, uint64_type );
+}
+
+variant::variant( int8_t val )
 {
    *reinterpret_cast<int64_t*>(this)  = val;
    set_variant_type( this, int64_type );
 }
 
+variant::variant( uint16_t val )
+{
+   *reinterpret_cast<uint64_t*>(this)  = val;
+   set_variant_type( this, uint64_type );
+}
+
+variant::variant( int16_t val )
+{
+   *reinterpret_cast<int64_t*>(this)  = val;
+   set_variant_type( this, int64_type );
+}
+
+variant::variant( uint32_t val )
+{
+   *reinterpret_cast<uint64_t*>(this)  = val;
+   set_variant_type( this, uint64_type );
+}
+
+variant::variant( int32_t val )
+{
+   *reinterpret_cast<int64_t*>(this)  = val;
+   set_variant_type( this, int64_type );
+}
+
+variant::variant( uint64_t val )
+{
+   *reinterpret_cast<uint64_t*>(this)  = val;
+   set_variant_type( this, uint64_type );
+}
+
 variant::variant( int64_t val )
 {
    *reinterpret_cast<int64_t*>(this)  = val;
    set_variant_type( this, int64_type );
 }
 
-variant::variant( int val )
-{
-   *reinterpret_cast<int64_t*>(this)  = val;
-   set_variant_type( this, int64_type );
-}
 variant::variant( float val )
 {
    *reinterpret_cast<double*>(this)  = val;
    set_variant_type( this, double_type );
 }
 
-variant::variant( uint64_t val )
-{
-   *reinterpret_cast<uint64_t*>(this)  = val;
-   set_variant_type( this, uint64_type );
-}
-
 variant::variant( double val )
 {
    *reinterpret_cast<double*>(this)  = val;
@@ -496,7 +493,6 @@ const string&        variant::get_string()const
   FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from type '${type}' to Object", ("type",get_type()) );
 }
 
-
 /// @throw if get_type() != object_type 
 const variant_object&  variant::get_object()const
 {
@@ -505,27 +501,45 @@ const variant_object&  variant::get_object()const
   FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from type '${type}' to Object", ("type",get_type()) );
 }
 
-void to_variant( const std::string& s, variant& v )
+void from_variant( const variant& var,  variants& vo )
 {
-    v = variant( fc::string(s) );
+   vo = var.get_array();
 }
 
 //void from_variant( const variant& var,  variant_object& vo )
 //{
 //   vo  = var.get_object();
 //}
-void from_variant( const variant& var,  string& vo )
-{
-   vo = var.as_string();
-}
-
-void from_variant( const variant& var,  variants& vo )
-{
-   vo = var.get_array();
-}
 
 void from_variant( const variant& var,  variant& vo ) { vo = var; }
 
+void to_variant( const uint8_t& var,  variant& vo )  { vo = uint64_t(var); }
+// TODO: warn on overflow?
+void from_variant( const variant& var,  uint8_t& vo ){ vo = static_cast<uint8_t>(var.as_uint64()); }
+
+void to_variant( const int8_t& var,  variant& vo )  { vo = int64_t(var); }
+// TODO: warn on overflow?
+void from_variant( const variant& var,  int8_t& vo ){ vo = static_cast<int8_t>(var.as_int64()); }
+
+void to_variant( const uint16_t& var,  variant& vo )  { vo = uint64_t(var); }
+// TODO: warn on overflow?
+void from_variant( const variant& var,  uint16_t& vo ){ vo = static_cast<uint16_t>(var.as_uint64()); }
+
+void to_variant( const int16_t& var,  variant& vo )  { vo = int64_t(var); }
+// TODO: warn on overflow?
+void from_variant( const variant& var,  int16_t& vo ){ vo = static_cast<int16_t>(var.as_int64()); }
+
+void to_variant( const uint32_t& var,  variant& vo )  { vo = uint64_t(var); }
+void from_variant( const variant& var,  uint32_t& vo )
+{
+   vo = static_cast<uint32_t>(var.as_uint64());
+}
+
+void from_variant( const variant& var,  int32_t& vo )
+{
+   vo = static_cast<int32_t>(var.as_int64());
+}
+
 void from_variant( const variant& var,  int64_t& vo )
 {
    vo = var.as_int64();
@@ -551,20 +565,34 @@ void from_variant( const variant& var,  float& vo )
    vo = static_cast<float>(var.as_double());
 }
 
-void from_variant( const variant& var,  int32_t& vo )
+void to_variant( const std::string& s, variant& v )
 {
-   vo = static_cast<int32_t>(var.as_int64());
+    v = variant( fc::string(s) );
 }
 
-void to_variant( const uint32_t& var,  variant& vo )  { vo = uint64_t(var); }
-void from_variant( const variant& var,  uint32_t& vo )
+void from_variant( const variant& var,  string& vo )
 {
-   vo = static_cast<uint32_t>(var.as_uint64());
+   vo = var.as_string();
 }
-void to_variant( const uint8_t& var,  variant& vo )  { vo = uint64_t(var); }
-void from_variant( const variant& var,  uint8_t& vo )
+
+void to_variant( const std::vector<char>& var,  variant& vo )
 {
-   vo = static_cast<uint8_t>(var.as_uint64());
+  if( var.size() )
+      //vo = variant(base64_encode((unsigned char*)var.data(),var.size()));
+      vo = variant(to_hex(var.data(),var.size()));
+  else vo = "";
+}
+void from_variant( const variant& var,  std::vector<char>& vo )
+{
+     auto str = var.as_string();
+     vo.resize( str.size() / 2 );
+     if( vo.size() )
+     {
+        size_t r = from_hex( str, vo.data(), vo.size() );
+        FC_ASSERT( r = vo.size() );
+     }
+//   std::string b64 = base64_decode( var.as_string() );
+//   vo = std::vector<char>( b64.c_str(), b64.c_str() + b64.size() );
 }
 
 string      format_string( const string& format, const variant_object& args )