From e3fbddca2a312742660890200f6807bf8ad7283d Mon Sep 17 00:00:00 2001
From: Matias Romeo <matias.romeo@gmail.com>
Date: Tue, 1 Aug 2017 04:36:19 -0300
Subject: [PATCH 1/2] Refactor AbiSerializer

---
 libraries/types/AbiSerializer.cpp             | 254 +++++++++++++-----
 .../types/include/eos/types/AbiSerializer.hpp |  10 +-
 2 files changed, 197 insertions(+), 67 deletions(-)

diff --git a/libraries/types/AbiSerializer.cpp b/libraries/types/AbiSerializer.cpp
index 863592a2d28..09de9db8e60 100644
--- a/libraries/types/AbiSerializer.cpp
+++ b/libraries/types/AbiSerializer.cpp
@@ -4,10 +4,189 @@
 
 namespace eos { namespace types {
 
+   template <typename T>
+   inline fc::variant variantFromStream(fc::datastream<const char*>& stream) {
+      T temp;
+      fc::raw::unpack( stream, temp );
+      return fc::variant(temp);
+   }
+
    AbiSerializer::AbiSerializer( const Abi& abi ) {
+      configureTypes();
       setAbi(abi);
    }
 
+   void AbiSerializer::configureTypes() {
+
+      native_types.emplace("UInt8", std::make_pair( []( auto& stream ) -> auto  {
+            return variantFromStream<uint8_t>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<uint8_t>() );
+         }
+      ));
+
+      native_types.emplace("UInt16", std::make_pair( []( auto& stream ) -> auto  { 
+            return variantFromStream<uint16_t>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<uint16_t>() );
+         }
+      ));
+
+      native_types.emplace("UInt32", std::make_pair( []( auto& stream ) -> auto  { 
+            return variantFromStream<uint32_t>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<uint32_t>() );
+         }
+      ));
+
+      native_types.emplace("UInt64", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<uint64_t>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<uint64_t>() );
+         }
+      ));
+
+      native_types.emplace("UInt128", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<UInt128>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<UInt128>() );
+         }
+      ));
+
+      native_types.emplace("UInt256", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<UInt256>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<UInt256>() );
+         }
+      ));
+
+      native_types.emplace("Int8", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<int8_t>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<int8_t>() );
+         }
+      ));
+
+      native_types.emplace("Int16", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<int16_t>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<int16_t>() );
+         }
+      ));
+
+      native_types.emplace("Int32", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<int32_t>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<int32_t>() );
+         }
+      ));
+
+      native_types.emplace("Int64", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<int64_t>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<int64_t>() );
+         }
+      ));
+
+      // native_types.emplace("Int128", std::make_pair(
+      //    []( auto& stream ) -> auto  {
+      //       return variantFromStream<__int128>(stream);
+      //    },
+      //    []( const fc::variant& var, fc::datastream<char*>& ds ){
+      //       fc::raw::pack( ds, var.as<__int128>() );
+      //    }
+      // ));
+
+      // native_types.emplace("Int256", std::make_pair(
+      //    []( auto& stream ) -> auto  {
+      //       return variantFromStream<Int256>(stream);
+      //    },
+      //    []( const fc::variant& var, fc::datastream<char*>& ds ){
+      //       fc::raw::pack( ds, var.as<Int256>() );
+      //    }
+      // ));
+
+      native_types.emplace("Name", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<Name>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<Name>() );
+         }
+      ));
+
+      native_types.emplace("Time", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<Time>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<Time>() );
+         }
+      ));
+
+      // native_types.emplace("String", std::make_pair(
+      //    []( auto& stream ) -> auto  {
+      //       return variantFromStream<String>(stream);
+      //    },
+      //    []( const fc::variant& var, fc::datastream<char*>& ds ){
+      //       fc::raw::pack( ds, var.as<String>() );
+      //    }
+      // ));
+
+      native_types.emplace("Checksum", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<Checksum>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<Checksum>() );
+         }
+      ));
+
+      native_types.emplace("Signature", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<Signature>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<Signature>() );
+         }
+      ));
+
+      native_types.emplace("FixedString32", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<FixedString32>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<FixedString32>() );
+         }
+      ));
+
+      native_types.emplace("FixedString16", std::make_pair(
+         []( auto& stream ) -> auto  {
+            return variantFromStream<FixedString16>(stream);
+         },
+         []( const fc::variant& var, fc::datastream<char*>& ds ){
+            fc::raw::pack( ds, var.as<FixedString16>() );
+         }
+      ));
+   }
+
    void AbiSerializer::setAbi( const Abi& abi ) {
       typedefs.clear();
       structs.clear();
@@ -37,16 +216,14 @@ namespace eos { namespace types {
    }
 
    bool AbiSerializer::isType( const TypeName& type )const {
-      static const std::set<TypeName> native = {"Name", "UInt8", "UInt32", "UInt64", "UInt128", "Time", "String"};
-      if( native.find(type) != native.end() ) return true;
+      if( native_types.find(type) != native_types.end() ) return true;
       if( typedefs.find(type) != typedefs.end() ) return isType( typedefs.find(type)->second );
       if( structs.find(type) != structs.end() ) return true;
       return false;
    }
 
    const Struct& AbiSerializer::getStruct( const TypeName& type )const {
-      if( typedefs.find(type) != typedefs.end() ) return getStruct( typedefs.find(type)->second );
-      auto itr = structs.find(type);
+      auto itr = structs.find( resolveType(type) );
       FC_ASSERT( itr != structs.end(), "Unknown struct ${type}", ("type",type) );
       return itr->second;
    }
@@ -82,7 +259,6 @@ namespace eos { namespace types {
       const auto& st = getStruct( type );
       if( st.base != TypeName() ) {
          binaryToVariant( resolveType(st.base), stream, obj );
-         return;
       }
       for( const auto& field : st.fields ) {
          obj( field.name, binaryToVariant( resolveType(field.type), stream ) );
@@ -92,41 +268,11 @@ namespace eos { namespace types {
    fc::variant AbiSerializer::binaryToVariant(const TypeName& type, fc::datastream<const char*>& stream )const
    {
       TypeName rtype = resolveType( type );
-      if( rtype == "Name" ) {
-        Name temp;
-        fc::raw::unpack( stream, temp );
-        return fc::variant(temp);
-      }
-      else if( rtype == "UInt8" ) {
-        unsigned char temp;
-        fc::raw::unpack( stream, temp );
-        return fc::variant(temp);
-      }
-      else if( rtype == "UInt32" ) {
-        uint32_t temp;
-        fc::raw::unpack( stream, temp );
-        return fc::variant(temp);
-      }
-      else if( rtype == "UInt64" ) {
-        uint64_t temp;
-        fc::raw::unpack( stream, temp );
-        return fc::variant(temp);
-      }
-      else if( rtype == "UInt128" ) {
-        UInt128 temp;
-        fc::raw::unpack( stream, temp );
-        return fc::variant(temp);
-      }
-      else if( rtype == "Time" ) {
-        Time temp;
-        fc::raw::unpack( stream, temp );
-        return fc::variant(temp);
-      }
-      else if( rtype == "String" ) {
-        String temp;
-        fc::raw::unpack( stream, temp );
-        return fc::variant(temp);
+      auto native_type = native_types.find(rtype);
+      if( native_type != native_types.end() ) {
+         return native_type->second.first(stream);
       }
+      
       fc::mutable_variant_object mvo;
       binaryToVariant( rtype, stream, mvo );
       return fc::variant( std::move(mvo) );
@@ -141,33 +287,9 @@ namespace eos { namespace types {
    {
       auto rtype = resolveType(type);
 
-      if( rtype == "Name" ) {
-         fc::raw::pack( ds, var.as<Name>() );
-         return;
-      }
-      else if( rtype == "UInt8" ) {
-         fc::raw::pack( ds, var.as<unsigned char>() );
-         return;
-      }
-      else if( rtype == "UInt32" ) {
-         fc::raw::pack( ds, var.as<uint32_t>() );
-         return;
-      }
-      else if( rtype == "UInt64" ) {
-         fc::raw::pack( ds, var.as<uint64_t>() );
-         return;
-      }
-      else if( rtype == "UInt128" ) {
-         fc::raw::pack( ds, var.as<UInt128>() );
-         return;
-      }
-      else if( rtype == "Time" ) {
-         fc::raw::pack( ds, var.as<uint32_t>() );
-         return;
-      }
-      else if( rtype == "String" ) {
-         fc::raw::pack( ds, var.as<String>() );
-         return;
+      auto native_type = native_types.find(rtype);
+      if( native_type != native_types.end() ) {
+         native_type->second.second(var, ds);
       } else {
          const auto& st = getStruct( rtype );
          const auto& vo = var.get_object();
diff --git a/libraries/types/include/eos/types/AbiSerializer.hpp b/libraries/types/include/eos/types/AbiSerializer.hpp
index 9bc603d3fea..0ef6fbf8b47 100644
--- a/libraries/types/include/eos/types/AbiSerializer.hpp
+++ b/libraries/types/include/eos/types/AbiSerializer.hpp
@@ -5,13 +5,15 @@ namespace eos { namespace types {
 
 using std::map;
 using std::string;
+using std::function;
+using std::pair;
 
 /**
  *  Describes the binary representation message and table contents so that it can
  *  be converted to and from JSON.
  */
 struct AbiSerializer {
-   AbiSerializer(){}
+   AbiSerializer(){ configureTypes(); }
    AbiSerializer( const Abi& abi );
    void setAbi( const Abi& abi );
 
@@ -20,6 +22,12 @@ struct AbiSerializer {
    map<Name,TypeName>      actions;
    map<Name,TypeName>      tables;
 
+   typedef std::function<fc::variant(fc::datastream<const char*>&)>  pack_function;
+   typedef std::function<void(const fc::variant&, fc::datastream<char*>&)>  unpack_function;
+   
+   map<TypeName, pair<pack_function, unpack_function>> native_types;
+   void configureTypes();
+
    void validate()const;
 
    TypeName resolveType( const TypeName& t )const;

From edd007e654a5c84a2ed65927948cc4b8a6fe5a05 Mon Sep 17 00:00:00 2001
From: Matias Romeo <matias.romeo@gmail.com>
Date: Tue, 1 Aug 2017 04:36:38 -0300
Subject: [PATCH 2/2] Add basic test for AbiSerializer

---
 tests/tests/abi_tests.cpp | 118 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 118 insertions(+)
 create mode 100644 tests/tests/abi_tests.cpp

diff --git a/tests/tests/abi_tests.cpp b/tests/tests/abi_tests.cpp
new file mode 100644
index 00000000000..3f5e1a159a8
--- /dev/null
+++ b/tests/tests/abi_tests.cpp
@@ -0,0 +1,118 @@
+#include <algorithm>
+#include <vector>
+#include <iterator>
+
+#include <boost/test/unit_test.hpp>
+
+#include <fc/variant.hpp>
+#include <fc/io/json.hpp>
+#include <fc/exception/exception.hpp>
+
+#include <eos/types/AbiSerializer.hpp>
+
+#include "../common/database_fixture.hpp"
+
+using namespace eos;
+using namespace chain;
+using namespace eos::types;
+
+BOOST_AUTO_TEST_SUITE(abi_tests)
+
+const char* my_abi = R"=====(
+{
+  "types": [{
+      "newTypeName": "SameAsName",
+      "type": "Name"
+    },{
+      "newTypeName": "SameAsB",
+      "type": "B"
+    },{
+      "newTypeName": "SameAsTime",
+      "type": "Time"
+    }
+  ],
+  "structs": [{
+      "name": "A",
+      "base" : "SameAsB",
+      "fields": {
+        "u_int8"   : "UInt8",
+        "u_int16"  : "UInt16",
+        "u_int32"  : "UInt32",
+        "u_int64"  : "UInt64",
+        "u_int128" : "UInt128",
+        "u_int256" : "UInt256"
+      }
+    },{
+      "name": "B",
+      "fields": {
+        "s_int8"   : "Int8",
+        "s_int16"  : "Int16",
+        "s_int32"  : "Int32",
+        "s_int64"  : "Int64",
+        "other"    : "Other"
+      }
+    },{
+      "name": "Other",
+      "fields" : {
+        "o_name"  : "SameAsName",
+        "o_time"  : "SameAsTime",
+        "o_chk"   : "Checksum",
+        "o_sig"   : "Signature",
+        "o_fix16" : "FixedString16",
+        "o_fix32" : "FixedString32"
+      }
+    }
+  ],
+  "actions": [],
+  "tables": []
+}
+)=====";
+
+BOOST_FIXTURE_TEST_CASE(general, testing_fixture)
+{ try {
+
+   auto abi = fc::json::from_string(my_abi).as<Abi>();
+
+   AbiSerializer abis(abi);
+   abis.validate();
+
+   const char *my_other = R"=====(
+    {
+      "u_int8"   : 1,
+      "u_int16"  : 2,
+      "u_int32"  : 3,
+      "u_int64"  : 4,
+      "u_int128" : "5",
+      "u_int256" : "6",
+      "s_int8"   : 7,
+      "s_int16"  : 8,
+      "s_int32"  : 9,
+      "s_int64"  : 10,
+      "other" : {
+         "o_name"  : "test.name",
+         "o_time"  : "2021-12-20T15:30",
+         "o_chk"   : "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+         "o_sig"   : "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015adba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad00",
+         "o_fix16" : "1234567890abcdef",
+         "o_fix32" : "1234567890abcdef1234567890abcdef",
+      }
+    }
+   )=====";
+
+   auto var = fc::json::from_string(my_other);
+   auto bytes = abis.variantToBinary("A", var);
+
+   auto var2 = abis.binaryToVariant("A", bytes);
+   std::string r = fc::json::to_string(var2);
+
+   std::cout << r << std::endl;
+   
+   auto bytes2 = abis.variantToBinary("A", var2);
+
+   BOOST_CHECK_EQUAL( fc::to_hex(bytes), fc::to_hex(bytes2) );
+   //BOOST_CHECK_EXCEPTION( , fc::assert_exception, is_assert_exception );
+
+} FC_LOG_AND_RETHROW() }
+
+
+BOOST_AUTO_TEST_SUITE_END()