EOS行为核心：解析插件chain_plugin

_http_plugin.add_api({
  CHAIN_RO_CALL(get_info, 200l),
  CHAIN_RO_CALL(get_block, 200),
  CHAIN_RO_CALL(get_block_header_state, 200),
  CHAIN_RO_CALL(get_account, 200),
  CHAIN_RO_CALL(get_code, 200),
  CHAIN_RO_CALL(get_code_hash, 200),
  CHAIN_RO_CALL(get_abi, 200),
  CHAIN_RO_CALL(get_raw_code_and_abi, 200),
  CHAIN_RO_CALL(get_raw_abi, 200),
  CHAIN_RO_CALL(get_table_rows, 200),
  CHAIN_RO_CALL(get_table_by_scope, 200),
  CHAIN_RO_CALL(get_currency_balance, 200),
  CHAIN_RO_CALL(get_currency_stats, 200),
  CHAIN_RO_CALL(get_producers, 200),
  CHAIN_RO_CALL(get_producer_schedule, 200),
  CHAIN_RO_CALL(get_scheduled_transactions, 200),
  CHAIN_RO_CALL(abi_json_to_bin, 200),
  CHAIN_RO_CALL(abi_bin_to_json, 200),
  CHAIN_RO_CALL(get_required_keys, 200),
  CHAIN_RO_CALL(get_transaction_id, 200),
  CHAIN_RW_CALL_ASYNC(push_block, chain_apis::read_write::push_block_results, 202),
  CHAIN_RW_CALL_ASYNC(push_transaction, chain_apis::read_write::push_transaction_results, 202),
  CHAIN_RW_CALL_ASYNC(push_transactions, chain_apis::read_write::push_transactions_results, 202)
});

#define CHAIN_RO_CALL(call_name, http_response_code) CALL(chain, ro_api, chain_apis::read_only, call_name, http_response_code)

/**
 *  @attention 目前调用CALL函数的只有read_only应用。
 *  @param api_name "chain'
 *  @param api_handle app().get_plugin<chain_plugin>().get_read_only_api();
 *  @param api_namespace chain_apis::read_only
 *  @param call_name -INHERIT
 *  @param http_response_code -INHERIT
 */
#define CALL(api_name, api_handle, api_namespace, call_name, http_response_code) \
{std::string("/v1/" #api_name "/" #call_name), \ /*拼接接口url：http://ip:port/v1/chain/{call_name}*/ \
    /*
     * @param body：http请求体
     * @param cb：回调函数，用于返回处理结果
     */ \
   [api_handle](string, string body, url_response_callback cb) mutable { \
       api_handle.validate(); \
       try { \
          if (body.empty()) body = "{}"; \
          /*
           * api_handle为chain_plugin中read_only类的实例
           * call_name为函数名，实现体找chain_plugin.cpp文件
           * 函数参数1个：此处规定了一个命名规则，接口名加入后缀_param即为请求参数结构
           */ \
          auto result = api_handle.call_name(fc::json::from_string(body).as<api_namespace::call_name ## _params>()); \
          /*回调函数返回处理结果，此处也规定了一个命名规则，接口名加入后缀_result即为返回结构，转化为json的格式返回。*/ \
          cb(http_response_code, fc::json::to_string(result)); \
       } catch (...) { \
          /*捕捉到异常，调用http_plugin的异常处理函数handle_exception*/ \
          http_plugin::handle_exception(#api_name, #call_name, body, cb); \
       } \
    } \
}

auto ro_api = app().get_plugin<chain_plugin>().get_read_only_api();

chain_apis::read_only get_read_only_api() const { return chain_apis::read_only(chain(), get_abi_serializer_max_time()); } //注意const修饰符，函数体内返回值是不可修改的。

read_only(const controller& db, const fc::microseconds& abi_serializer_max_time)
    : db(db), abi_serializer_max_time(abi_serializer_max_time) {}

#define CHAIN_RW_CALL_ASYNC(call_name, call_result, http_response_code) CALL_ASYNC(chain, rw_api, chain_apis::read_write, call_name, call_result, http_response_code)

/**
 *  @attention 目前调用CALL_ASYNC函数的只有read_write的应用。
 *  @param api_name "chain'
 *  @param api_handle app().get_plugin<chain_plugin>().get_read_write_api();
 *  @param api_namespace chain_apis::read_write
 *  @param call_name -INHERIT
 *  @param call_result -INHERIT
 *  @param http_response_code -INHERIT
 */
#define CALL_ASYNC(api_name, api_handle, api_namespace, call_name, call_result, http_response_code) \
{std::string("/v1/" #api_name "/" #call_name), \ /*同上，拼接接口url：http://ip:port/v1/chain/{call_name}*/ \
    /*
     * http处理请求的函数结构不变，同上。
     * @param body：http请求体
     * @param cb：回调函数，用于返回处理结果
     */ \
   [api_handle](string, string body, url_response_callback cb) mutable { \
      if (body.empty()) body = "{}"; \
      api_handle.validate(); \
      /*
       * api_handle为chain_plugin中read_only类的实例
       * call_name为函数名，实现体找chain_plugin.cpp文件
       * 函数参数2个：
       * @param 此处规定了一个命名规则，接口名加入后缀_param即为请求参数结构
       * @param lambda表达式，将cb和body按值传递进内部函数，该内部函数整体作为异步操作的回调函数，注意与http的回调函数cb区分。
       */ \
      api_handle.call_name(fc::json::from_string(body).as<api_namespace::call_name ## _params>(),\
         [cb, body](const fc::static_variant<fc::exception_ptr, call_result>& result){\
            /*捕获异常，分发异常处理*/ \
            if (result.contains<fc::exception_ptr>()) {\
               try {\
                  result.get<fc::exception_ptr>()->dynamic_rethrow_exception();\
               } catch (...) {\
                  http_plugin::handle_exception(#api_name, #call_name, body, cb);\
               }\
            } else {\
                /*
                 * 异步处理成功，通过http的回调函数cb返回结果。
                 */ \
               cb(http_response_code, result.visit(async_result_visitor()));\
            }\
         });\
   }\
}

struct async_result_visitor : public fc::visitor<std::string> {
   template<typename T>
   std::string operator()(const T& v) const {
      return fc::json::to_string(v); //与CALL处理返回结果相同的是，此处做的也是转换json的工作。
   }
};

template<typename visitor>
typename visitor::result_type visit(const visitor& v)const {
    return impl::storage_ops<0, Types...>::apply(_tag, storage, v);
}

auto rw_api = app().get_plugin<chain_plugin>().get_read_write_api();

chain_apis::read_write get_read_write_api() { return chain_apis::read_write(chain(), get_abi_serializer_max_time()); }

read_write(controller& db, const fc::microseconds& abi_serializer_max_time)
   : db(db), abi_serializer_max_time(abi_serializer_max_time) {}

FC_REFLECT( eosio::chain_apis::read_only::get_required_keys_params, (transaction)(available_keys) )
FC_REFLECT( eosio::chain_apis::read_only::get_required_keys_result, (required_keys) )

struct get_required_keys_params {
  fc::variant transaction;
  flat_set<public_key_type> available_keys;
};
struct get_required_keys_result {
  flat_set<public_key_type> required_keys;
};

// 返回值为read_only的实体成员get_info_results结构的实例。
read_only::get_info_results read_only::get_info(const read_only::get_info_params&) const {
   const auto& rm = db.get_resource_limits_manager();
   return {
      // 以下字段都与get_info_results结构匹配，最终构造出get_info_results实例返回。
      eosio::utilities::common::itoh(static_cast<uint32_t>(app().version())), // server_version
      db.get_chain_id(), // chain_id
      db.fork_db_head_block_num(), // head_block_num
      db.last_irreversible_block_num(), // last_irreversible_block_num
      db.last_irreversible_block_id(), // last_irreversible_block_id
      db.fork_db_head_block_id(), // head_block_id
      db.fork_db_head_block_time(), // head_block_time
      db.fork_db_head_block_producer(), // head_block_producer
      rm.get_virtual_block_cpu_limit(), // virtual_block_cpu_limit
      rm.get_virtual_block_net_limit(), // virtual_block_net_limit
      rm.get_block_cpu_limit(), // block_cpu_limit
      rm.get_block_net_limit(), // block_net_limit
      //std::bitset<64>(db.get_dynamic_global_properties().recent_slots_filled).to_string(), // recent_slots
      //__builtin_popcountll(db.get_dynamic_global_properties().recent_slots_filled) / 64.0, // participation_rate
      app().version_string(), // server_version_string
   };
}

// 特殊的是，此处并没有创建一个get_block_result的结构体作为返回值的容器，是利用了variant语法将signed_block_ptr转换成可输出的状态。
fc::variant read_only::get_block(const read_only::get_block_params& params) const {
   signed_block_ptr block;
   // 如果参数block_num_or_id为空或者block_num_or_id的长度大于64，属于非法参数不处理，会报错。
   EOS_ASSERT(!params.block_num_or_id.empty() && params.block_num_or_id.size() <= 64, chain::block_id_type_exception, "Invalid Block number or ID, must be greater than 0 and less than 64 characters" );
   try {
      // 通过variant语法将参数block_num_or_id类型擦除然后通过as语法转化为block_id_type类型，
      block = db.fetch_block_by_id(fc::variant(params.block_num_or_id).as<block_id_type>());
      if (!block) {// 如果通过id的方法获得的block为空，则尝试使用区块号的方式获取。
         block = db.fetch_block_by_number(fc::to_uint64(params.block_num_or_id));// 利用to_uint64将参数转型。
      }// 如果获取失败，抛出异常，无效的参数block_num_or_id
   } EOS_RETHROW_EXCEPTIONS(chain::block_id_type_exception, "Invalid block ID: ${block_num_or_id}", ("block_num_or_id", params.block_num_or_id))

   EOS_ASSERT( block, unknown_block_exception, "Could not find block: ${block}", ("block", params.block_num_or_id));
   // 通过校验，开始返回对象。
   fc::variant pretty_output;
   // i将结果block的数据通过resolver解析到pretty_output
   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];

   return fc::mutable_variant_object(pretty_output.get_object())
           ("id", block->id())
           ("block_num",block->block_num())
           ("ref_block_prefix", ref_block_prefix);
}

namespace eosio { namespace chain {
   digest_type block_header::digest()const
   {
      return digest_type::hash(*this);// hash算法为sha256，然后使用fc::raw::pack打包获取结果
   }
   
   uint32_t block_header::num_from_id(const block_id_type& id)
   {
      return fc::endian_reverse_u32(id._hash[0]);// 实际上是对区块id并入区块号的算法的逆向工程，获得区块号。
   }
   
   // id的类型为block_id_type
   block_id_type block_header::id()const
   {
      // id不包括签名区块头属性，尤其是生产者签名除外。
      block_id_type result = digest();//digest_type::hash(*this)，this是id()的调用者。
      result._hash[0] &= 0xffffffff00000000;//对结果进行位操作，并入一个十六进制头。
      result._hash[0] += fc::endian_reverse_u32(block_num()); // 通过上一个区块id找到其区块号然后自增获得当前区块号。并入id数据成为其一部分。
      return result;
   }
} }

fc::variant vo;
fc::to_variant( static_cast<const block_header_state&>(*b), vo );// block_state_ptr b;
return vo;

struct get_account_results {
  name                       account_name; // 账户名，入参的值。
  uint32_t                   head_block_num = 0; // 头块号，controller的状态主库db获取
  fc::time_point             head_block_time; // 头块时间，controller的状态主库db获取

  bool                       privileged = false; // 是否超级账户，默认false。controller的状态主库db获取账户的属性之一。
  fc::time_point             last_code_update; // 最后的code修改时间，例如给账户set contract的时间。controller的状态主库db获取账户的属性之一。
  fc::time_point             created; // 账户创建时间。controller的状态主库db获取账户的属性之一。

  optional<asset>            core_liquid_balance; // 主币的余额，在accounts状态表里查到的

  int64_t                    ram_quota  = 0; // 内存限额(资源相关部分有详细介绍)，从controller的资源管理器获取
  int64_t                    net_weight = 0; // 网络带宽资源权重，从controller的资源管理器获取
  int64_t                    cpu_weight = 0; // cpu资源权重，从controller的资源管理器获取

  account_resource_limit     net_limit; // 网络带宽资源，包括已使用、剩余可用、总量。从controller的资源管理器获取
  account_resource_limit     cpu_limit; // cpu带宽资源，包括已使用、剩余可用、总量。从controller的资源管理器获取
  int64_t                    ram_usage = 0; // 内存已使用量。从controller的资源管理器获取

  vector<permission>         permissions; // 账户的权限内容(账户多签名部分有详细介绍)，在状态主库的表里查到的。

  fc::variant                total_resources; // 总资源量，包括网络、cpu、内存资源总量。在userres状态表里查到的
  fc::variant                self_delegated_bandwidth; // 自我抵押带宽。在delband状态表里查到的
  fc::variant                refund_request; // 退款请求。在refunds状态表里查到的
  fc::variant                voter_info; // 投票相关。在voters状态表里查到的
};

{
    "account_name": "eosio.token",
    "code_as_wasm": true
}

read_only::get_code_results read_only::get_code( const get_code_params& params )const {
   get_code_results result;
   result.account_name = params.account_name;
   const auto& d = db.db();
   const auto& accnt  = d.get<account_object,by_name>( params.account_name );// 从controller状态库中获取账户信息
   // 当前默认不支持返回wast数据
   EOS_ASSERT( params.code_as_wasm, unsupported_feature, "Returning WAST from get_code is no longer supported" );

   if( accnt.code.size() ) {
      if (params.code_as_wasm) {
          // 完整的原始账户的code的数据
         result.wasm = string(accnt.code.begin(), accnt.code.end());
      }
      // 获得code的哈希值：将账户信息下的code的data和size值做sha256哈希得到的值
      result.code_hash = fc::sha256::hash( accnt.code.data(), accnt.code.size() );
   }
   // 获取账户的abi数据：通过abi_serializer将账户的abi数据解析出来。
   abi_def abi;
   if( abi_serializer::to_abi(accnt.abi, abi) ) {
      result.abi = std::move(abi);
   }

   return result;
}

read_only::get_raw_code_and_abi_results read_only::get_raw_code_and_abi( const get_raw_code_and_abi_params& params)const {
   get_raw_code_and_abi_results result;
   result.account_name = params.account_name;

   const auto& d = db.db();
   const auto& accnt = d.get<account_object,by_name>(params.account_name);
   result.wasm = blob{{accnt.code.begin(), accnt.code.end()}}; // 原始wasm值，完整取出即可。
   result.abi = blob{{accnt.abi.begin(), accnt.abi.end()}}; // 原始abi值，完整取出即可。

   return result;
}

struct get_table_rows_params {
  bool        json = false; // 是否是json的格式
  name        code; // 传入code值，即拥有该table的账户名
  string      scope; // 传入scope值，即查询条件
  name        table; // 传入table的名字
  string      table_key; // table主键
  string      lower_bound; // 设置检索数据的下限，默认是first
  string      upper_bound; // 设置检索数据的上限，默认是last
  uint32_t    limit = 10; // 数据结果的最大条目限制
  string      key_type;  // 通过指定键的数据类型，定位查询依赖的键
  string      index_position; // 通过传入键的位置，，定位查询依赖的键。1 - 主键(first), 2 - 二级索引 (multi_index定义), 3 - 三级索引，等等
  string      encode_type{"dec"}; //加密类型，有十进制还是十六进制，默认是十进制dec。
};

struct get_table_rows_result {
  vector<fc::variant> rows; // 数据集合。一行是一条，无论是十六进制加密串还是解析成json对象，都代表一行。
  bool                more = false; // 如果最后显示的元素(受制于limit)并不是数据库中最后一个，则该字段会置为true
};

// 对比入参对象的table名字是否与通过index反查的table名字保持一致。
EOS_ASSERT( p.table == table_with_index, chain::contract_table_query_exception, "Invalid table name ${t}", ( "t", p.table ));
auto table_type = get_table_type( abi, p.table );// 获得table类型
if( table_type == KEYi64 || p.key_type == "i64" || p.key_type == "name" ) {//支持这三种table类型
 return get_table_rows_ex<key_value_index>(p,abi);// 具体检索table的函数。
}
// 如果是已支持的三种table类型之外的，则会报错。
EOS_ASSERT( false, chain::contract_table_query_exception,  "Invalid table type ${type}", ("type",table_type)("abi",abi));

/**
* 检索table的核心函数
* @tparam IndexType 模板类，支持不同的索引类型
* @param p get_table_rows接口入参对象
* @param abi 通过controller查询入参code对应的程序abi
* @return 查询结果
*/
template <typename IndexType>
read_only::get_table_rows_result get_table_rows_ex( const read_only::get_table_rows_params& p, const abi_def& abi )const {
  read_only::get_table_rows_result result; // 首先定义结果容器
  const auto& d = db.db(); // 状态主库对象
  uint64_t scope = convert_to_type<uint64_t>(p.scope, "scope"); // 获得查询条件。

  abi_serializer abis;
  abis.set_abi(abi, abi_serializer_max_time);// 将abi_def类型的abi通过序列化转到abi_serializer类型的对象abis。

  // 查询状态库表的标准范式，返回的是通过code、scope、table检索到的结果集的数据迭代器，
  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, chain::by_scope_primary>(); // 传入查询依赖的键，指定迭代器的索引。
     decltype(t_id->id) next_tid(t_id->id._id + 1);
     auto lower = idx.lower_bound(boost::make_tuple(t_id->id)); // 获取结果集上限
     auto upper = idx.lower_bound(boost::make_tuple(next_tid)); // 获取结果集下限

     if (p.lower_bound.size()) {// 如果入参对象设置了结果集下限
        if (p.key_type == "name") { // 主键类型是账户名字，设置下限对象
           name s(p.lower_bound);
           lower = idx.lower_bound( boost::make_tuple( t_id->id, s.value ));
        } else {// 主键类型是其他类型，设置下限对象
           auto lv = convert_to_type<typename IndexType::value_type::key_type>( p.lower_bound, "lower_bound" );
           lower = idx.lower_bound( boost::make_tuple( t_id->id, lv ));
        }
     }
     if (p.upper_bound.size()) {// 如果入参对象设置了结果集上限
        if (p.key_type == "name") {// 主键类型是账户名字，设置上限对象
           name s(p.upper_bound);
           upper = idx.lower_bound( boost::make_tuple( t_id->id, s.value ));
        } else {// 主键类型是其他类型，设置上限对象
           auto uv = convert_to_type<typename IndexType::value_type::key_type>( p.upper_bound, "upper_bound" );
           upper = idx.lower_bound( boost::make_tuple( t_id->id, uv ));
        }
     }
     // 迭代器启动迭代，开始检索
     vector<char> data;
     auto end = fc::time_point::now() + fc::microseconds(1000 * 10); /// 10ms 是最长时间
     unsigned int count = 0;
     auto itr = lower;
     for (; itr != upper; ++itr) {
        copy_inline_row(*itr, data); // 将迭代器当前指针指向的对象复制到data容器中去。

        if (p.json) { // 处理data为json格式，通过方法binary_to_variant，向result的结果集rows中插入解析后的明文json格式的data
           result.rows.emplace_back( abis.binary_to_variant( abis.get_table_type(p.table), data, abi_serializer_max_time, shorten_abi_errors ) );
        } else { // 未要求json格式，则直接返回data，data不是可读的。
           result.rows.emplace_back(fc::variant(data));
        }
        if (++count == p.limit || fc::time_point::now() > end) { // 两个限制：一是结果集行数limit限制，二是执行时间是否超时
           ++itr;
           break;
        }
     }
     if (itr != upper) { // 如果实际返回的结果集并没有完全输出所有符合要求的数据，则将more字段置为true，提醒用户还有符合要求的数据没显示。
        result.more = true;
     }
  }
  return result;
}

struct get_table_by_scope_params {
  name        code; // 必须字段，传入账户名
  name        table = 0; // 可选，作为过滤器
  string      lower_bound; // 范围下限，可选
  string      upper_bound; // 范围上限，可选
  uint32_t    limit = 10; // 范围数量，限制条目
};

struct get_currency_balance_params {
  name             code; // 账户名，token合约的owner，一般是eosio.token账户
  name             account; // 账户名，检索条件，查询该账户的余额
  optional<string> symbol; // 检索条件，需要的token符号，例如SYS(主币)，EOS等。
};

vector<asset> read_only::get_currency_balance( const read_only::get_currency_balance_params& p )const {
   const abi_def abi = eosio::chain_apis::get_abi( db, p.code ); // get_abi与前面RPC接口实现函数为同一个。先通过账户code获取eosio.token合约对象abi数据。
   auto table_type = get_table_type( abi, "accounts" ); // 在abi中找到accounts表，返回该表的索引类型。

   vector<asset> results; // 结果容器
   walk_key_value_table(p.code, p.account, N(accounts), [&](const key_value_object& obj){
       // 表数据的value值超过了assert数据类型的大小，说明是无效数据。
      EOS_ASSERT( obj.value.size() >= sizeof(asset), chain::asset_type_exception, "Invalid data on table");

      asset cursor;
      // obj.value.data()是原始数据。
      fc::datastream<const char *> ds(obj.value.data(), obj.value.size());
      fc::raw::unpack(ds, cursor); // 将datastream数据解包到cursor

      EOS_ASSERT( cursor.get_symbol().valid(), chain::asset_type_exception, "Invalid asset");

      if( !p.symbol || boost::iequals(cursor.symbol_name(), *p.symbol) ) { // 对比token符号，一致的添加至结果集。
        results.emplace_back(cursor);
      }
      return !(p.symbol && boost::iequals(cursor.symbol_name(), *p.symbol));
   });

   return results;
}

string get_table_type( const abi_def& abi, const name& table_name ) {
   for( const auto& t : abi.tables ) { //遍历abi下的所有table
      if( t.name == table_name ){ // 找到符合条件的table
         return t.index_type; // 返回该table的索引类型。
      }
   }
   // 如果没查到，报错提示当前ABI中并未找到目标table。
   EOS_ASSERT( false, chain::contract_table_query_exception, "Table ${table} is not specified in the ABI", ("table",table_name) );
}

fc::variant read_only::get_currency_stats( const read_only::get_currency_stats_params& p )const {
   fc::mutable_variant_object results; // 结果容器
   const abi_def abi = eosio::chain_apis::get_abi( db, p.code );
   auto table_type = get_table_type( abi, "stat" ); // 在abi的表中找到stat表，返回其索引类型。
   uint64_t scope = ( eosio::chain::string_to_symbol( 0, boost::algorithm::to_upper_copy(p.symbol).c_str() ) >> 8 );

   walk_key_value_table(p.code, scope, N(stat), [&](const key_value_object& obj){
      EOS_ASSERT( obj.value.size() >= sizeof(read_only::get_currency_stats_result), chain::asset_type_exception, "Invalid data on table");
      fc::datastream<const char *> ds(obj.value.data(), obj.value.size());
      read_only::get_currency_stats_result result; // 接口的返回对象
      fc::raw::unpack(ds, result.supply);// 已发行量
      fc::raw::unpack(ds, result.max_supply);// 最大发行量
      fc::raw::unpack(ds, result.issuer); // 发行人
      results[result.supply.symbol_name()] = result; // 数组下标为token符号，内容是token信息。
      return true;
   });
   return results;
}

struct get_scheduled_transactions_params {
  bool        json = false; 
  string      lower_bound;  // 传入时间戳或者交易id。
  uint32_t    limit = 50;
};

struct get_scheduled_transactions_result {
  fc::variants  transactions; // 事务数组
  string        more;
};

auto row = fc::mutable_variant_object()
          ("trx_id", itr->trx_id)
          ("sender", itr->sender)
          ("sender_id", itr->sender_id)
          ("payer", itr->payer)
          ("delay_until", itr->delay_until)
          ("expiration", itr->expiration)
          ("published", itr->published)
    ;

struct abi_json_to_bin_params {
  name         code; // 合约owner账户
  name         action; // action名字
  fc::variant  args; // action参数，json明文格式
};

read_only::abi_json_to_bin_result read_only::abi_json_to_bin( const read_only::abi_json_to_bin_params& params )const try {
   abi_json_to_bin_result result;
   const auto code_account = db.db().find<account_object,by_name>( params.code ); // 找到合约owner账户
   EOS_ASSERT(code_account != nullptr, contract_query_exception, "Contract can't be found ${contract}", ("contract", params.code));

   abi_def abi;
   if( abi_serializer::to_abi(code_account->abi, abi) ) {// 反序列化解析abi
      abi_serializer abis( abi, abi_serializer_max_time );
      auto action_type = abis.get_action_type(params.action); // 获得action类型，在abi的action中寻找目标action
      EOS_ASSERT(!action_type.empty(), action_validate_exception, "Unknown action ${action} in contract ${contract}", ("action", params.action)("contract", params.code));
      try {
         result.binargs = abis.variant_to_binary( action_type, params.args, abi_serializer_max_time, shorten_abi_errors ); //将入参args由json转为二进制
      } EOS_RETHROW_EXCEPTIONS(chain::invalid_action_args_exception,
                                "'${args}' is invalid args for action '${action}' code '${code}'. expected '${proto}'",
                                ("args", params.args)("action", params.action)("code", params.code)("proto", action_abi_to_variant(abi, action_type)))
   } else {
      EOS_ASSERT(false, abi_not_found_exception, "No ABI found for ${contract}", ("contract", params.code));
   }
   return result;
} FC_RETHROW_EXCEPTIONS( warn, "code: ${code}, action: ${action}, args: ${args}",
                         ("code", params.code)( "action", params.action )( "args", params.args ))

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, abi_serializer_max_time);
   try {
      abi_serializer::from_variant(params.transaction, pretty_input, resolver, abi_serializer_max_time);//根据明文json事务，通过abi序列化器将数据输出到pretty_input，转为transaction对象。
   } EOS_RETHROW_EXCEPTIONS(chain::transaction_type_exception, "Invalid transaction")
   // 通过认证管理器获得必须密钥
   auto required_keys_set = db.get_authorization_manager().get_required_keys( pretty_input, params.available_keys, fc::seconds( pretty_input.delay_sec ));
   get_required_keys_result result;
   result.required_keys = required_keys_set;
   return result;
}

flat_set<public_key_type> authorization_manager::get_required_keys( const transaction& trx,
                                                                       const flat_set<public_key_type>& candidate_keys,
                                                                       fc::microseconds provided_delay
                                                                     )const
   {
      auto checker = make_auth_checker( [&](const permission_level& p){ return get_permission(p).auth; },// 获取权限内容
                                        _control.get_global_properties().configuration.max_authority_depth, // 当前全局属性的最大权限深度
                                        candidate_keys,
                                        {},
                                        provided_delay,
                                        _noop_checktime
                                      ); // 获取认证检查器

      for (const auto& act : trx.actions ) { // 遍历事务的action
         for (const auto& declared_auth : act.authorization) {
            EOS_ASSERT( checker.satisfied(declared_auth), unsatisfied_authorization,
                        "transaction declares authority '${auth}', but does not have signatures for it.",
                        ("auth", declared_auth) );// 如果在密钥集合中发现没有能满足任意action需要的权限的，即报错提醒。
         }
      }

      return checker.used_keys();
   }

struct signed_block : public signed_block_header {
  using signed_block_header::signed_block_header; // 签名区块头
  signed_block() = default; // 默认构造器
  signed_block( const signed_block_header& h ):signed_block_header(h){} // 构造器，传入签名区块头
  vector<transaction_receipt>   transactions; // 包含收到事务的集合
  extensions_type               block_extensions; // 区块扩展
};

void read_write::push_block(const read_write::push_block_params& params, next_function<read_write::push_block_results> next) {
   try {
      app().get_method<incoming::methods::block_sync>()(std::make_shared<signed_block>(params));// 命名空间incoming::methods下的成员block_sync
      next(read_write::push_block_results{});// 调用next写入结果，实际上结果为空。
   } catch ( boost::interprocess::bad_alloc& ) {
      chain_plugin::handle_db_exhaustion();
   } CATCH_AND_CALL(next);
}

namespace incoming {
  namespace methods {
     // 推送block到一个独立的provider
     using block_sync = method_decl<chain_plugin_interface, void(const signed_block_ptr&), first_provider_policy>; 
  }
}

/**
* @tparam Tag - API鉴定器，用于区分相同方法的不同签名
* @tparam FunctionSig - 方法签名
* @tparam DispatchPolicy - 分发策略，规定了provider是如何被访问的
*/
template< typename Tag, typename FunctionSig, template <typename> class DispatchPolicy = first_success_policy>
struct  method_decl {
  using method_type = method<FunctionSig, DispatchPolicy<FunctionSig>>;
  using tag_type = Tag;
};

my->_incoming_block_sync_provider = app().get_method<incoming::methods::block_sync>().register_provider([this](const signed_block_ptr& block){
  my->on_incoming_block(block);
});

chain::controller& chain = app().get_plugin<chain_plugin>().chain();

signed_block_ptr controller::fetch_block_by_id( block_id_type id )const {// 传入区块id
   auto state = my->fork_db.get_block(id);// 在本地fork_db库中查找，是否之前已接收到分叉库了。
   if( state && state->block ) return state->block; //　如果找到了，则返回区块。
   auto bptr = fetch_block_by_number( block_header::num_from_id(id) ); //将id转为区块号，尝试以区块号来查找。
   if( bptr && bptr->id() == id ) return bptr; // 以区块号来查找并且找到了，则直接返回区块。
   return signed_block_ptr(); // 返回为空的signed_block对象。
}

auto ensure = fc::make_scoped_exit([this](){
   schedule_production_loop(); // 正常计划的出块循环节奏。
});

emit( self.pre_accepted_block, b ); // 预承认区块信号

emit( self.accepted_block_header, new_header_state ); // 承认区块头信号

emit( self.irreversible_block, new_header_state ); // 不可逆区块信号

struct push_transaction_results {
  chain::transaction_id_type  transaction_id; // 事务id
  fc::variant                 processed; // 加工过的事务对象
};

chain::controller& chain = app().get_plugin<chain_plugin>().chain();

_transaction_ack_channel.publish(std::pair<fc::exception_ptr, packed_transaction_ptr>(response.get<fc::exception_ptr>(), trx)); // 传入事务对象trx

_transaction_ack_channel(app().get_channel<compat::channels::transaction_ack>())

namespace compat {
  namespace channels {
     using transaction_ack       = channel_decl<struct accepted_transaction_tag, std::pair<fc::exception_ptr, packed_transaction_ptr>>;
  }
}

/**
* @tparam Tag - API鉴定器，用于区分相同数据类型
* @tparam Data - channel携带的数据类型
* @tparam DispatchPolicy - 当前channel的分发策略。默认是drop_exceptions
*/
template< typename Tag, typename Data, typename DispatchPolicy = drop_exceptions >
struct channel_decl {
  using channel_type = channel<Data, DispatchPolicy>;
  using tag_type = Tag;
};

my->incoming_transaction_ack_subscription = app().get_channel<channels::transaction_ack>().subscribe(boost::bind(&net_plugin_impl::transaction_ack, my.get(), _1));

void net_plugin_impl::transaction_ack(const std::pair<fc::exception_ptr, packed_transaction_ptr>& results) {
  transaction_id_type id = results.second->id();
  if (results.first) { // first位置是用来放异常信息的，如果first不为空则说明有异常。
     fc_ilog(logger,"signaled NACK, trx-id = ${id} : ${why}",("id", id)("why", results.first->to_detail_string()));
     dispatcher->rejected_transaction(id);// 调用rejected_transaction，从received_transactions接收事务集合中将其删除。
  } else {
     fc_ilog(logger,"signaled ACK, trx-id = ${id}",("id", id));
     dispatcher->bcast_transaction(*results.second);
  }
}

void dispatch_manager::bcast_transaction (const packed_transaction& trx) {
  std::set<connection_ptr> skips; // 跳过的数据集合
  transaction_id_type id = trx.id();
  auto range = received_transactions.equal_range(id);
  for (auto org = range.first; org != range.second; ++org) {
     skips.insert(org->second); // 在接收事务集合中找到对应id的事务数据遍历放于skips。
  }
  received_transactions.erase(range.first, range.second); // 从received_transactions接收事务集合中将其删除。
  for (auto ref = req_trx.begin(); ref != req_trx.end(); ++ref) {
     if (*ref == id) { // 本地请求事务集合中，找到目标事务删除
        req_trx.erase(ref);
        break;
     }
  }
  if( my_impl->local_txns.get<by_id>().find( id ) != my_impl->local_txns.end( ) ) {
     fc_dlog(logger, "found trxid in local_trxs" );
     return;// 在本地事务集合中找到目标事务了，终止不必重复处理。
  }
  uint32_t packsiz = 0;
  uint32_t bufsiz = 0;
  time_point_sec trx_expiration = trx.expiration();
  net_message msg(trx);
  packsiz = fc::raw::pack_size(msg);
  bufsiz = packsiz + sizeof(packsiz);
  vector<char> buff(bufsiz);
  fc::datastream<char*> ds( buff.data(), bufsiz);
  ds.write( reinterpret_cast<char*>(&packsiz), sizeof(packsiz) );
  fc::raw::pack( ds, msg );// trx转为net_message结构，打包通过数据流ds到缓存buff中。
  node_transaction_state nts = {id,
                                trx_expiration,
                                trx,
                                std::move(buff),
                                0, 0, 0};
  my_impl->local_txns.insert(std::move(nts)); // 插入到本地事务集，net_plugin自定义的多索引库node_transaction_index中。

  if( !large_msg_notify || bufsiz <= just_send_it_max) { // max-implicit-request参数决定just_send_it_max，最大请求数量
     my_impl->send_all( trx, [id, &skips, trx_expiration](connection_ptr c) -> bool {
           if( skips.find(c) != skips.end() || c->syncing ) {// skips中一旦有了当前连接，或者connection正在同步中，则退出。
              return false;
           }
           const auto& bs = c->trx_state.find(id); // 连接中的事务状态多索引库中寻找目标事务，返回事务数据
           bool unknown = bs == c->trx_state.end();
           if( unknown) {// 没找到则插入
              c->trx_state.insert(transaction_state({id,true,true,0,trx_expiration,time_point() }));
              fc_dlog(logger, "sending whole trx to ${n}", ("n",c->peer_name() ) );
           } else { // 找到则更新过期时间、状态库数据
              update_txn_expiry ute(trx_expiration);
              c->trx_state.modify(bs, ute);
           }
           return unknown;
        });
  }else {// 超过最大请求数量以后，不处理trx，而是pending_notify
     notice_message pending_notify;
     pending_notify.known_trx.mode = normal;
     pending_notify.known_trx.ids.push_back( id );
     pending_notify.known_blocks.mode = none;
     my_impl->send_all(pending_notify, [id, &skips, trx_expiration](connection_ptr c) -> bool {
           if (skips.find(c) != skips.end() || c->syncing) {
              return false;
           }
           const auto& bs = c->trx_state.find(id);
           bool unknown = bs == c->trx_state.end();
           if( unknown) {
              fc_dlog(logger, "sending notice to ${n}", ("n",c->peer_name() ) );
              c->trx_state.insert(transaction_state({id,false,true,0,trx_expiration,time_point() }));
           } else {
              update_txn_expiry ute(trx_expiration);
              c->trx_state.modify(bs, ute);
           }
           return unknown;
        });
  }
}