Pass abi serialization max time to abi_serializer constructor.

Author: heifner

libraries/abi_generator/abi_generator.cpp

@@ -318,7 +318,7 @@ bool abi_generator::is_string(const string& type) {
 }
 
 void abi_generator::get_all_fields(const struct_def& s, vector<field_def>& fields) {
-  abi_serializer abis(*output);
+  abi_serializer abis(*output, fc::seconds(1)); // No risk to client side serialization taking a long time
 
   for(const auto& field : s.fields) {
     fields.push_back(field);

libraries/chain/abi_serializer.cpp

@@ -49,9 +49,9 @@ namespace eosio { namespace chain {
       );
    }
 
-   abi_serializer::abi_serializer( const abi_def& abi ) {
+   abi_serializer::abi_serializer( const abi_def& abi, const fc::microseconds& max_serialization_time ) {
       configure_built_in_types();
-      set_abi(abi);
+      set_abi(abi, max_serialization_time);
    }
 
    void abi_serializer::configure_built_in_types() {
@@ -97,7 +97,8 @@ namespace eosio { namespace chain {
       built_in_types.emplace("extended_asset",            pack_unpack<extended_asset>());
    }
 
-   void abi_serializer::set_abi(const abi_def& abi) {
+   void abi_serializer::set_abi(const abi_def& abi, const fc::microseconds& max_serialization_time) {
+      const fc::time_point deadline = fc::time_point::now() + max_serialization_time;
       typedefs.clear();
       structs.clear();
       actions.clear();
@@ -108,8 +109,8 @@ namespace eosio { namespace chain {
          structs[st.name] = st;
 
       for( const auto& td : abi.types ) {
-         FC_ASSERT(is_type(td.type), "invalid type", ("type",td.type));
-         FC_ASSERT(!is_type(td.new_type_name), "type already exists", ("new_type_name",td.new_type_name));
+         FC_ASSERT(_is_type(td.type, 0, deadline, max_serialization_time), "invalid type", ("type",td.type));
+         FC_ASSERT(!_is_type(td.new_type_name, 0, deadline, max_serialization_time), "type already exists", ("new_type_name",td.new_type_name));
          typedefs[td.new_type_name] = td.type;
       }
 
@@ -132,7 +133,7 @@ namespace eosio { namespace chain {
       FC_ASSERT( tables.size() == abi.tables.size() );
       FC_ASSERT( error_messages.size() == abi.error_messages.size() );
 
-      validate();
+      validate(max_serialization_time);
    }
 
    bool abi_serializer::is_builtin_type(const type_name& type)const {
@@ -176,12 +177,12 @@ namespace eosio { namespace chain {
       }
    }
 
-   bool abi_serializer::_is_type(const type_name& rtype, size_t recursion_depth, const fc::time_point& deadline)const {
+   bool abi_serializer::_is_type(const type_name& rtype, size_t recursion_depth, const fc::time_point& deadline, const fc::microseconds& max_serialization_time)const {
       FC_ASSERT( fc::time_point::now() < deadline, "serialization time limit ${t}us exceeded", ("t", max_serialization_time) );
       if( ++recursion_depth > max_recursion_depth) return false;
       auto type = fundamental_type(rtype);
       if( built_in_types.find(type) != built_in_types.end() ) return true;
-      if( typedefs.find(type) != typedefs.end() ) return _is_type(typedefs.find(type)->second, recursion_depth, deadline);
+      if( typedefs.find(type) != typedefs.end() ) return _is_type(typedefs.find(type)->second, recursion_depth, deadline, max_serialization_time);
       if( structs.find(type) != structs.end() ) return true;
       return false;
    }
@@ -192,7 +193,7 @@ namespace eosio { namespace chain {
       return itr->second;
    }
 
-   void abi_serializer::validate()const {
+   void abi_serializer::validate(const fc::microseconds& max_serialization_time)const {
       const fc::time_point deadline = fc::time_point::now() + max_serialization_time;
       for( const auto& t : typedefs ) { try {
          vector<type_name> types_seen{t.first, t.second};
@@ -205,7 +206,7 @@ namespace eosio { namespace chain {
          }
       } FC_CAPTURE_AND_RETHROW( (t) ) }
       for( const auto& t : typedefs ) { try {
-         FC_ASSERT(is_type(t.second), "", ("type",t.second) );
+         FC_ASSERT(_is_type(t.second, 0, deadline, max_serialization_time), "", ("type",t.second) );
       } FC_CAPTURE_AND_RETHROW( (t) ) }
       for( const auto& s : structs ) { try {
          if( s.second.base != type_name() ) {
@@ -221,17 +222,17 @@ namespace eosio { namespace chain {
          }
          for( const auto& field : s.second.fields ) { try {
             FC_ASSERT( fc::time_point::now() < deadline, "serialization time limit ${t}us exceeded", ("t", max_serialization_time) );
-            FC_ASSERT(is_type(field.type) );
+            FC_ASSERT(_is_type(field.type, 0, deadline, max_serialization_time) );
          } FC_CAPTURE_AND_RETHROW( (field) ) }
       } FC_CAPTURE_AND_RETHROW( (s) ) }
       for( const auto& a : actions ) { try {
         FC_ASSERT( fc::time_point::now() < deadline, "serialization time limit ${t}us exceeded", ("t", max_serialization_time) );
-        FC_ASSERT(is_type(a.second), "", ("type",a.second) );
+        FC_ASSERT(_is_type(a.second, 0, deadline, max_serialization_time), "", ("type",a.second) );
       } FC_CAPTURE_AND_RETHROW( (a)  ) }
 
       for( const auto& t : tables ) { try {
         FC_ASSERT( fc::time_point::now() < deadline, "serialization time limit ${t}us exceeded", ("t", max_serialization_time) );
-        FC_ASSERT(is_type(t.second), "", ("type",t.second) );
+        FC_ASSERT(_is_type(t.second, 0, deadline, max_serialization_time), "", ("type",t.second) );
       } FC_CAPTURE_AND_RETHROW( (t)  ) }
    }
 
@@ -369,7 +370,7 @@ namespace eosio { namespace chain {
    { try {
       FC_ASSERT( ++recursion_depth < max_recursion_depth, "recursive definition, max_recursion_depth ${r} ", ("r", max_recursion_depth) );
       FC_ASSERT( fc::time_point::now() < deadline, "serialization time limit ${t}us exceeded", ("t", max_serialization_time) );
-      if( !is_type(type) ) {
+      if( !_is_type(type, recursion_depth, deadline, max_serialization_time) ) {
          return var.as<bytes>();
       }
 

libraries/chain/include/eosio/chain/abi_serializer.hpp

@@ -27,16 +27,14 @@ namespace impl {
  */
 struct abi_serializer {
    abi_serializer(){ configure_built_in_types(); }
-   explicit abi_serializer( const abi_def& abi );
-   void set_abi(const abi_def& abi);
-
-   void validate()const;
+   abi_serializer( const abi_def& abi, const fc::microseconds& max_serialization_time );
+   void set_abi(const abi_def& abi, const fc::microseconds& max_serialization_time);
 
    type_name resolve_type(const type_name& t)const;
    bool      is_array(const type_name& type)const;
    bool      is_optional(const type_name& type)const;
-   bool      is_type(const type_name& type)const {
-      return _is_type(type, 0, fc::time_point::now() + max_serialization_time);
+   bool      is_type(const type_name& type, const fc::microseconds& max_serialization_time)const {
+      return _is_type(type, 0, fc::time_point::now() + max_serialization_time, max_serialization_time);
    }
    bool      is_builtin_type(const type_name& type)const;
    bool      is_integer(const type_name& type) const;
@@ -117,7 +115,9 @@ struct abi_serializer {
    void _binary_to_variant(const type_name& type, fc::datastream<const char*>& stream, fc::mutable_variant_object& obj,
                            size_t recursion_depth, const fc::time_point& deadline, const fc::microseconds& max_serialization_time)const;
 
-   bool _is_type(const type_name& type, size_t recursion_depth, const fc::time_point& deadline)const;
+   bool _is_type(const type_name& type, size_t recursion_depth, const fc::time_point& deadline, const fc::microseconds& max_serialization_time)const;
+
+   void validate(const fc::microseconds& max_serialization_time)const;
 
    friend struct impl::abi_from_variant;
    friend struct impl::abi_to_variant;

libraries/chain/include/eosio/chain/controller.hpp

@@ -219,13 +219,13 @@ namespace eosio { namespace chain {
          wasm_interface& get_wasm_interface();
 
 
-         optional<abi_serializer> get_abi_serializer( account_name n )const {
+         optional<abi_serializer> get_abi_serializer( account_name n, const fc::microseconds& max_serialization_time )const {
             if( n.good() ) {
                try {
                   const auto& a = get_account( n );
                   abi_def abi;
                   if( abi_serializer::to_abi( a.abi, abi ))
-                     return abi_serializer( abi );
+                     return abi_serializer( abi, max_serialization_time );
                } FC_CAPTURE_AND_LOG((n))
             }
             return optional<abi_serializer>();
@@ -234,7 +234,9 @@ namespace eosio { namespace chain {
          template<typename T>
          fc::variant to_variant_with_abi( const T& obj, const fc::microseconds& max_serialization_time ) {
             fc::variant pretty_output;
-            abi_serializer::to_variant( obj, pretty_output, [&]( account_name n ){ return get_abi_serializer( n ); }, max_serialization_time);
+            abi_serializer::to_variant( obj, pretty_output,
+                                        [&]( account_name n ){ return get_abi_serializer( n, max_serialization_time ); },
+                                        max_serialization_time);
             return pretty_output;
          }
 

libraries/testing/include/eosio/testing/tester.hpp

@@ -229,7 +229,7 @@ namespace eosio { namespace testing {
                   const auto& accnt = control->db().get<account_object, by_name>( name );
                   abi_def abi;
                   if( abi_serializer::to_abi( accnt.abi, abi )) {
-                     return abi_serializer( abi );
+                     return abi_serializer( abi, abi_serializer_max_time );
                   }
                   return optional<abi_serializer>();
                } FC_RETHROW_EXCEPTIONS( error, "Failed to find or parse ABI for ${name}", ("name", name))

libraries/testing/tester.cpp

@@ -428,7 +428,7 @@ namespace eosio { namespace testing {
                                    const variant_object& data )const { try {
       const auto& acnt = control->get_account(code);
       auto abi = acnt.get_abi();
-      chain::abi_serializer abis(abi);
+      chain::abi_serializer abis(abi, abi_serializer_max_time);
     //  auto a = control->get_account(code).get_abi();
 
       string action_type_name = abis.get_action_type(acttype);

plugins/chain_plugin/chain_plugin.cpp

@@ -910,7 +910,7 @@ static fc::variant get_global_row( const database& db, const abi_def& abi, const
 read_only::get_producers_result read_only::get_producers( const read_only::get_producers_params& p ) const {
    const abi_def abi = eosio::chain_apis::get_abi(db, N(eosio));
    const auto table_type = get_table_type(abi, N(producers));
-   const abi_serializer abis{ abi };
+   const abi_serializer abis{ abi, abi_serializer_max_time };
    EOS_ASSERT(table_type == KEYi64, chain::contract_table_query_exception, "Invalid table type ${type} for table producers", ("type",table_type));
 
    const auto& d = db.db();
@@ -969,13 +969,13 @@ read_only::get_producer_schedule_result read_only::get_producer_schedule( const
 
 template<typename Api>
 struct resolver_factory {
-   static auto make(const Api *api) {
-      return [api](const account_name &name) -> optional<abi_serializer> {
-         const auto *accnt = api->db.db().template find<account_object, by_name>(name);
+   static auto make(const Api* api, const fc::microseconds& max_serialization_time) {
+      return [api, max_serialization_time](const account_name &name) -> optional<abi_serializer> {
+         const auto* accnt = api->db.db().template find<account_object, by_name>(name);
          if (accnt != nullptr) {
             abi_def abi;
             if (abi_serializer::to_abi(accnt->abi, abi)) {
-               return abi_serializer(abi);
+               return abi_serializer(abi, max_serialization_time);
             }
          }
 
@@ -985,8 +985,8 @@ struct resolver_factory {
 };
 
 template<typename Api>
-auto make_resolver(const Api *api) {
-   return resolver_factory<Api>::make(api);
+auto make_resolver(const Api* api, const fc::microseconds& max_serialization_time) {
+   return resolver_factory<Api>::make(api, max_serialization_time);
 }
 
 fc::variant read_only::get_block(const read_only::get_block_params& params) const {
@@ -1003,7 +1003,7 @@ fc::variant read_only::get_block(const read_only::get_block_params& params) cons
    EOS_ASSERT( block, unknown_block_exception, "Could not find block: ${block}", ("block", params.block_num_or_id));
 
    fc::variant pretty_output;
-   abi_serializer::to_variant(*block, pretty_output, make_resolver(this), abi_serializer_max_time);
+   abi_serializer::to_variant(*block, pretty_output, make_resolver(this, abi_serializer_max_time), abi_serializer_max_time);
 
    uint32_t ref_block_prefix = block->id()._hash[1];
 
@@ -1049,7 +1049,7 @@ void read_write::push_transaction(const read_write::push_transaction_params& par
 
    try {
       auto pretty_input = std::make_shared<packed_transaction>();
-      auto resolver = make_resolver(this);
+      auto resolver = make_resolver(this, abi_serializer_max_time);
       try {
          abi_serializer::from_variant(params, *pretty_input, resolver, abi_serializer_max_time);
       } EOS_RETHROW_EXCEPTIONS(chain::packed_transaction_type_exception, "Invalid packed transaction")
@@ -1193,7 +1193,7 @@ read_only::get_account_results read_only::get_account( const get_account_params&
    //const abi_def abi = get_abi( db, N(eosio) );
    abi_def abi;
    if( abi_serializer::to_abi(code_account.abi, abi) ) {
-      abi_serializer abis( abi );
+      abi_serializer abis( abi, abi_serializer_max_time );
       //get_table_rows_ex<key_value_index, by_scope_primary>(p,abi);
 
       const auto token_code = N(eosio.token);
@@ -1275,7 +1275,7 @@ read_only::abi_json_to_bin_result read_only::abi_json_to_bin( const read_only::a
 
    abi_def abi;
    if( abi_serializer::to_abi(code_account->abi, abi) ) {
-      abi_serializer abis( abi );
+      abi_serializer abis( abi, abi_serializer_max_time );
       auto action_type = abis.get_action_type(params.action);
       EOS_ASSERT(!action_type.empty(), action_validate_exception, "Unknown action ${action} in contract ${contract}", ("action", params.action)("contract", params.code));
       try {
@@ -1295,7 +1295,7 @@ read_only::abi_bin_to_json_result read_only::abi_bin_to_json( const read_only::a
    const auto& code_account = db.db().get<account_object,by_name>( params.code );
    abi_def abi;
    if( abi_serializer::to_abi(code_account.abi, abi) ) {
-      abi_serializer abis( abi );
+      abi_serializer abis( abi, abi_serializer_max_time );
       result.args = abis.binary_to_variant( abis.get_action_type( params.action ), params.binargs, abi_serializer_max_time );
    } else {
       EOS_ASSERT(false, abi_not_found_exception, "No ABI found for ${contract}", ("contract", params.code));
@@ -1305,7 +1305,7 @@ read_only::abi_bin_to_json_result read_only::abi_bin_to_json( const read_only::a
 
 read_only::get_required_keys_result read_only::get_required_keys( const get_required_keys_params& params )const {
    transaction pretty_input;
-   auto resolver = make_resolver(this);
+   auto resolver = make_resolver(this, abi_serializer_max_time);
    try {
       abi_serializer::from_variant(params.transaction, pretty_input, resolver, abi_serializer_max_time);
    } EOS_RETHROW_EXCEPTIONS(chain::transaction_type_exception, "Invalid transaction")

plugins/chain_plugin/include/eosio/chain_plugin/chain_plugin.hpp

@@ -302,7 +302,7 @@ class read_only {
       uint64_t scope = convert_to_type<uint64_t>(p.scope, "scope");
 
       abi_serializer abis;
-      abis.set_abi(abi);
+      abis.set_abi(abi, abi_serializer_max_time);
       const auto* t_id = d.find<chain::table_id_object, chain::by_code_scope_table>(boost::make_tuple(p.code, scope, p.table));
       if (t_id != nullptr) {
          const auto &idx = d.get_index<IndexType, Scope>();

plugins/txn_test_gen_plugin/txn_test_gen_plugin.cpp

@@ -124,6 +124,8 @@ struct txn_test_gen_plugin_impl {
          auto chainid = app().get_plugin<chain_plugin>().get_chain_id();
          auto abi_serializer_max_time = app().get_plugin<chain_plugin>().get_abi_serializer_max_time();
 
+         abi_serializer eosio_token_serializer{fc::json::from_string(eosio_token_abi).as<abi_def>(), abi_serializer_max_time};
+
          fc::crypto::private_key txn_test_receiver_A_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'a')));
          fc::crypto::private_key txn_test_receiver_B_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'b')));
          fc::crypto::private_key txn_test_receiver_C_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'c')));
@@ -244,6 +246,7 @@ struct txn_test_gen_plugin_impl {
 
       controller& cc = app().get_plugin<chain_plugin>().chain();
       auto abi_serializer_max_time = app().get_plugin<chain_plugin>().get_abi_serializer_max_time();
+      abi_serializer eosio_token_serializer{fc::json::from_string(eosio_token_abi).as<abi_def>(), abi_serializer_max_time};
       //create the actions here
       act_a_to_b.account = N(txn.test.t);
       act_a_to_b.name = N(transfer);
@@ -293,14 +296,15 @@ struct txn_test_gen_plugin_impl {
       try {
          controller& cc = app().get_plugin<chain_plugin>().chain();
          auto chainid = app().get_plugin<chain_plugin>().get_chain_id();
+         auto abi_serializer_max_time = app().get_plugin<chain_plugin>().get_abi_serializer_max_time();
 
          name sender("txn.test.a");
          name recipient("txn.test.b");
          fc::crypto::private_key a_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'a')));
          fc::crypto::private_key b_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'b')));
 
          static uint64_t nonce = static_cast<uint64_t>(fc::time_point::now().sec_since_epoch()) << 32;
-         abi_serializer eosio_serializer(cc.db().find<account_object, by_name>(config::system_account_name)->get_abi());
+         abi_serializer eosio_serializer(cc.db().find<account_object, by_name>(config::system_account_name)->get_abi(), abi_serializer_max_time);
 
          uint32_t reference_block_num = cc.last_irreversible_block_num();
          if (txn_reference_block_lag >= 0) {
@@ -362,8 +366,6 @@ struct txn_test_gen_plugin_impl {
    action act_b_to_a;
 
    int32_t txn_reference_block_lag;
-
-   abi_serializer eosio_token_serializer{fc::json::from_string(eosio_token_abi).as<abi_def>()};
 };
 
 txn_test_gen_plugin::txn_test_gen_plugin() {}

programs/cleos/main.cpp

@@ -2553,11 +2553,11 @@ int main( int argc, char** argv ) {
    });
 
    //resolver for ABI serializer to decode actions in proposed transaction in multisig contract
-   auto resolver = [](const name& code) -> optional<abi_serializer> {
+   auto resolver = [abi_serializer_max_time](const name& code) -> optional<abi_serializer> {
       auto result = call(get_code_func, fc::mutable_variant_object("account_name", code.to_string()));
       if (result["abi"].is_object()) {
          //std::cout << "ABI: " << fc::json::to_pretty_string(result) << std::endl;
-         return optional<abi_serializer>(abi_serializer(result["abi"].as<abi_def>()));
+         return optional<abi_serializer>(abi_serializer(result["abi"].as<abi_def>(), abi_serializer_max_time));
       } else {
          std::cerr << "ABI for contract " << code.to_string() << " not found. Action data will be shown in hex only." << std::endl;
          return optional<abi_serializer>();

programs/eosio-abigen/main.cpp

@@ -88,7 +88,7 @@ int main(int argc, const char **argv) { abi_def output; try {
    if(!result) {
       result = Tool.run(create_factory(abi_verbose, abi_opt_sfs, abi_context, output, contract, actions).get());
       if(!result) {
-         abi_serializer(output).validate();
+         abi_serializer abis(output, fc::seconds(1)); // No risk to client side serialization taking a long time
          fc::variant vabi;
          to_variant(output, vabi);