【精】EOS智能合约：system系统合约源码分析

struct permission_level_weight {
  permission_level  permission;
  uint16_t          weight;

  EOSLIB_SERIALIZE( permission_level_weight, (permission)(weight) )
};

struct key_weight {
  eosio::public_key  key;
  uint16_t           weight;

  EOSLIB_SERIALIZE( key_weight, (key)(weight) )
};

struct wait_weight {
  uint32_t           wait_sec;
  uint16_t           weight;

  EOSLIB_SERIALIZE( wait_weight, (wait_sec)(weight) )
};

struct authority {
  uint32_t                              threshold = 0;
  std::vector<key_weight>               keys;
  std::vector<permission_level_weight>  accounts;
  std::vector<wait_weight>              waits;

  EOSLIB_SERIALIZE( authority, (threshold)(keys)(accounts)(waits) )
};

struct block_header {
  uint32_t                                  timestamp;
  name                                      producer;
  uint16_t                                  confirmed = 0;
  capi_checksum256                          previous;
  capi_checksum256                          transaction_mroot;
  capi_checksum256                          action_mroot;
  uint32_t                                  schedule_version = 0;
  std::optional<eosio::producer_schedule>   new_producers;

  EOSLIB_SERIALIZE(block_header, (timestamp)(producer)(confirmed)(previous)(transaction_mroot)(action_mroot)
                                 (schedule_version)(new_producers))
};

struct producer_schedule {
  // 时间计划的版本号，按顺序递增。
  uint32_t                     version;
  // 此计划的生产者列表，包括其签名密钥
  std::vector<producer_key>    producers;
};

struct producer_key {
  name             producer_name;
  // 此生产者使用的区块签名密钥
  public_key       block_signing_key;
  // 重载运算符小于号，producer_key的两个对象进行小于号比较时，返回的是其name类型的生产者账户的比较。
  friend constexpr bool operator < ( const producer_key& a, const producer_key& b ) {
     return a.producer_name < b.producer_name;
  }

  EOSLIB_SERIALIZE( producer_key, (producer_name)(block_signing_key) )
};

struct [[eosio::table("abihash"), eosio::contract("eosio.system")]] abi_hash {
  name              owner;
  capi_checksum256  hash;
  uint64_t primary_key()const { return owner.value; } // 以账户的值作为该表的主键。

  EOSLIB_SERIALIZE( abi_hash, (owner)(hash) )
};

[[eosio::action]]
void newaccount( name             creator,
                 name             name,
                 ignore<authority> owner,
                 ignore<authority> active);

template <typename T>
struct [[eosio::ignore]] ignore {};

struct name {  
public:  
   enum class raw : uint64_t {};  
   // 构建一个新的name对象，初始化默认为0  
   constexpr name() : value(0) {}  
   // 使用给定的unit64_t类型的值构建一个新的name对象。  
   constexpr explicit name( uint64_t v )  
   :value(v)  
   {}  
   // 使用给定的一个范围的枚举类型，构建一个新的name对象。  
   constexpr explicit name( name::raw r )  
   :value(static_cast<uint64_t>(r))  
   {}  
   // 使用给定的字符串构建一个新的name对象。  
   constexpr explicit name( std::string_view str )  
   :value(0)  
   {  
      if( str.size() > 13 ) { // 字符串最长不能超过12  
         eosio::check( false, "string is too long to be a valid name" );  
      }  
      if( str.empty() ) {  
         return;  
      }  
      // 将字符串转为uint64_t  
      auto n = std::min( (uint32_t)str.size(), (uint32_t)12u );  
      for( decltype(n) i = 0; i < n; ++i ) {  
         value <<= 5;  
         value |= char_to_value( str[i] );  
      }  
      value <<= ( 4 + 5*(12 - n) );  
      if( str.size() == 13 ) {  
         uint64_t v = char_to_value( str[12] );  
         if( v > 0x0Full ) {  
            eosio::check(false, "thirteenth character in name cannot be a letter that comes after j");  
         }  
         value |= v;  
      }  
   }  
   // 将一个Base32符号的char转换为它对应的值。  
   static constexpr uint8_t char_to_value( char c ) {  
      if( c == '.')  
         return 0;  
      else if( c >= '1' && c <= '5' )  
         return (c - '1') + 1;  
      else if( c >= 'a' && c <= 'z' )  
         return (c - 'a') + 6;  
      else // 字符中出现了不允许的内容。  
         eosio::check( false, "character is not in allowed character set for names" );  
      return 0; // 流程控制将不会到达这里，这一行是为了防止warn信息。  
   }  
   // 返回一个name对象的长度，运算方法。  
   constexpr uint8_t length()const {  
      constexpr uint64_t mask = 0xF800000000000000ull;  
      if( value == 0 )  
         return 0;  
      uint8_t l = 0;  
      uint8_t i = 0;  
      for( auto v = value; i < 13; ++i, v <<= 5 ) {  
         if( (v & mask) > 0 ) {  
            l = i;  
         }  
      }  
      return l + 1;  
   }  
   // 返回一个name对象的后缀，完整的运算方法。  
   constexpr name suffix()const {  
      uint32_t remaining_bits_after_last_actual_dot = 0;  
      uint32_t tmp = 0;  
      for( int32_t remaining_bits = 59; remaining_bits >= 4; remaining_bits -= 5 ) { // remaining_bits必须有符号整数  
         // 从左到右依次遍历name中的字符，共12次  
         auto c = (value >> remaining_bits) & 0x1Full;  
         if( !c ) { // 如果当前字符是点  
            tmp = static_cast<uint32_t>(remaining_bits);  
         } else { // 如果当前字符不是点  
            remaining_bits_after_last_actual_dot = tmp;  
         }  
      }  
      uint64_t thirteenth_character = value & 0x0Full;  
      if( thirteenth_character ) { // 如果第13个字符不是点  
         remaining_bits_after_last_actual_dot = tmp;  
      }  
      if( remaining_bits_after_last_actual_dot == 0 ) // 除了潜在的前导点之外，name中没有实际的点  
         return name{value};  
      // 此时，remaining_bits_after_last_actual_dot必须在4到59的范围内（并且限制为5的增量）。  
      // 除了4个最低有效位（对应于第13个字符）之外，对应于最后一个实际点之后的字符的剩余位的掩码。  
      uint64_t mask = (1ull << remaining_bits_after_last_actual_dot) - 16;  
      uint32_t shift = 64 - remaining_bits_after_last_actual_dot;  
      return name{ ((value & mask) << shift) + (thirteenth_character << (shift-1)) };  
   }  
   // 将name类型转为raw枚举类型：基于name对象的值，返回一个raw枚举类型的实例。  
   constexpr operator raw()const { return raw(value); }  
   // 显式转换一个name的uint64_t值为bool，如果name的值不为0，返回true。  
   constexpr explicit operator bool()const { return value != 0; }  
   // 根据给定的char缓冲区，以字符串的类型写入name对象。参数begin：char缓冲区的开头，参数end：刚好超过char缓冲区的位置，作为结尾。  
   char* write_as_string( char* begin, char* end )const {  
      static const char* charmap = ".12345abcdefghijklmnopqrstuvwxyz";  
      constexpr uint64_t mask = 0xF800000000000000ull;  
      if( (begin + 13) < begin || (begin + 13) > end ) return begin;  
      auto v = value;  
      for( auto i = 0;   i < 13; ++i, v <<= 5 ) {  
         if( v == 0 ) return begin;  
         auto indx = (v & mask) >> (i == 12 ? 60 : 59);  
         *begin = charmap[indx];  
         ++begin;  
      }  
      return begin;  
   }  
   // 将name对象转为一个字符串返回。  
   std::string to_string()const {  
      char buffer[13];  
      auto end = write_as_string( buffer, buffer + sizeof(buffer) );  
      return {buffer, end};  
   }  
   // 重载运算符等于号，给定两个name对象，如果他们的value相等，则返回true，说明对象也相等。  
   friend constexpr bool operator == ( const name& a, const name& b ) {  
      return a.value == b.value;  
   }  
   // 重载运算符符不等于，如果给定的两个name对象的value不相等，则返回true，说明对象也不相等。  
   friend constexpr bool operator != ( const name& a, const name& b ) {  
      return a.value != b.value;  
   }  
   // 重载运算符小于号，原理同上。  
   friend constexpr bool operator < ( const name& a, const name& b ) {  
      return a.value < b.value;  
   }  
   uint64_t value = 0; // 其实name对象只有一个有效属性，就是value，以上都是name对象的构造方式、限制条件、各种转型以及运算符重载。  
  
   EOSLIB_SERIALIZE( name, (value) )  
};  

namespace eosiosystem {
   using eosio::asset;
   using eosio::symbol;

   typedef double real_type;

   // 使用Bancor算法在两种不同资产类型中间创造一个50对50的中继。bancor交易所的状态完全包含在这个结构体中。使用此API没有任何副作用。
   struct [[eosio::table, eosio::contract("eosio.system")]] exchange_state {
      asset    supply; // 资产供应
      struct connector { // 连接器
         asset balance; // 资产余额
         double weight = .5; // 权重
         
         EOSLIB_SERIALIZE( connector, (balance)(weight) )
      };
      connector base; // 基本连接器
      connector quote; // 引用连接器
      uint64_t primary_key()const { return supply.symbol.raw(); } // 该table主键
      asset convert_to_exchange( connector& c, asset in ); // 通过连接器c将输入资产in转换为发行资产issued。
      asset convert_from_exchange( connector& c, asset in ); // 通过连接器c将输入资产in转换为输出资产out
      asset convert( asset from, const symbol& to ); // 核心功能：将一种资产转为另一种符号的等价资产。例如将10 SYS的资产转为EOS是20 EOS，币币交易。

      EOSLIB_SERIALIZE( exchange_state, (supply)(base)(quote) )
   };
   // 内存市场状态表
   typedef eosio::multi_index< "rammarket"_n, exchange_state > rammarket;
}

asset exchange_state::convert(asset from, const symbol &to)
{
   auto sell_symbol = from.symbol;           // 原来的符号，作为卖出币
   auto ex_symbol = supply.symbol;           // 中转币的符号
   auto base_symbol = base.balance.symbol;   // base连接器资产的符号
   auto quote_symbol = quote.balance.symbol; // quote连接器资产的符号
   if (sell_symbol != ex_symbol)
   { // 如果卖出币不是中转币
      if (sell_symbol == base_symbol)
      {                                          // 如果卖出币等于base连接器资产
         from = convert_to_exchange(base, from); // 通过base连接器转换卖出币
      }
      else if (sell_symbol == quote_symbol)
      {                                           // 如果卖出币等于quote连接器资产
         from = convert_to_exchange(quote, from); // 通过quote连接器转换卖出币
      }
      else
      { // 其他卖出币无任何连接器的情况视为无效币币兑换行为。
         eosio_assert(false, "invalid sell");
      }
   }
   else
   {                         // 如果卖出币是中转币
      if (to == base_symbol) // 如果买入币等于base连接器资产
      {
         from = convert_from_exchange(base, from); // 通过base连接器转换卖出币
      }
      else if (to == quote_symbol) // 如果买入币等于quote连接器资产
      {
         from = convert_from_exchange(quote, from); // 通过quote连接器转换卖出币
      }
      else
      { // 其他卖出币无任何连接器的情况视为无效币币兑换行为。
         eosio_assert(false, "invalid conversion");
      }
   }
   if (to != from.symbol) // 如果经过一轮转换以后，from和to资产仍旧没有统一符号，则再次调一遍转换。
      return convert(from, to);
   return from; // 最后成功得到转换为等价的to币
}

struct asset
{
   int64_t amount;                                        // 资产数量
   symbol_type symbol;                                    // 资产符号名称，详见以下symbol_type源码分析。
   static constexpr int64_t max_amount = (1LL << 62) - 1; // 资产数量最大值，取决于int64_t类型的取值范围。
   // 通过给定的符号名称以及资产数量构建一个新的资产对象。
   explicit asset(int64_t a = 0, symbol_type s = CORE_SYMBOL)
       : amount(a), symbol{s}
   {
      eosio_assert(is_amount_within_range(), "magnitude of asset amount must be less than 2^62");
      eosio_assert(symbol.is_valid(), "invalid symbol name");
   }
   // 检查资产数量是否在范围以内，是否超过了最大限额。
   bool is_amount_within_range() const { return -max_amount <= amount && amount <= max_amount; }
   // 检查资产对象是否有效，有效资产的数量应该小于等于最大限额同时它的符号名称也是有效的。
   bool is_valid() const { return is_amount_within_range() && symbol.is_valid(); }

   // 设置资产的数量
   void set_amount(int64_t a)
   {
      amount = a;
      eosio_assert(is_amount_within_range(), "magnitude of asset amount must be less than 2^62");
   }

   /**
    * 以下为资产对象的运算符重载，包含
    * 取负,-=,+=,+,-,*=,*(数乘以资产，资产乘以数),/(资产除以数，资产除以资产),/=,==,!=,<,<=,>,>=
    * 源码部分省略。
    */

   // 打印资产
   void print() const
   {
      int64_t p = (int64_t)symbol.precision();
      int64_t p10 = 1;
      while (p > 0)
      {
         p10 *= 10;
         --p;
      }
      p = (int64_t)symbol.precision();

      char fraction[p + 1];
      fraction[p] = '\0';
      auto change = amount % p10;
      for (int64_t i = p - 1; i >= 0; --i)
      {
         fraction[i] = (change % 10) + '0';
         change /= 10;
      }
      printi(amount / p10);
      prints(".");
      prints_l(fraction, uint32_t(p));
      prints(" ");
      symbol.print(false);
   }

   EOSLIB_SERIALIZE(asset, (amount)(symbol))
};

/**
 * @brief 存储关于符号相关的信息的结构体
 */
struct symbol_type
{
   symbol_name value; // uint64_t类型的符号名称
   symbol_type() {}
   symbol_type(symbol_name s) : value(s) {}                           // 符号的类型
   bool is_valid() const { return is_valid_symbol(value); }           // 符号是否有效
   uint64_t precision() const { return value & 0xff; }                // 符号类型中包含对资产精度的要求，即小数点后几位数。
   uint64_t name() const { return value >> 8; }                       // 返回代表符号名称的uint64_t的值
   uint32_t name_length() const { return symbol_name_length(value); } // 返回符号名称的长度
   operator symbol_name() const { return value; }                     //重载符号对象的()运算符，返回符号名称的uint64_t值
   void print(bool show_precision = true) const
   { // 打印符号信息，包含uint64_t转字符的算法。
      if (show_precision)
      {
         ::eosio::print(precision()); // 打印符号的精度
         prints(",");
      }
      //uint64_t转字符
      auto sym = value;
      sym >>= 8;
      for (int i = 0; i < 7; ++i)
      {
         char c = (char)(sym & 0xff);
         if (!c)
            return;
         prints_l(&c, 1);
         sym >>= 8;
      }
   }

   EOSLIB_SERIALIZE(symbol_type, (value))
};

struct extended_asset : public asset
{
   account_name contract; // 资产拥有者

   // 获得资产的扩展符号
   extended_symbol get_extended_symbol() const { return extended_symbol(symbol, contract); }

   // 默认构造器，构造一个扩展资产对象
   extended_asset() = default;

   // 通过给定的数量和扩展符号构造一个扩展资产对象。
   extended_asset(int64_t v, extended_symbol s) : asset(v, s), contract(s.contract) {}
   // 通过给定的资产以及拥有者账户名构造一个扩展资产。
   extended_asset(asset a, account_name c) : asset(a), contract(c) {}

   // 打印相关信息
   void print() const
   {
      asset::print();
      prints("@");
      printn(contract);
   }

   /**
    * 运算符重载，包括符号取反,-,+
    * 主要是对资产拥有者的操作，其他的操作于asset一致。
    */

   EOSLIB_SERIALIZE(extended_asset, (amount)(symbol)(contract))
};

/** 
 * @brief 更新已入选生产节点 
 *  
 * @param block_time 区块时间 
 */  
void system_contract::update_elected_producers( block_timestamp block_time ) {  
    _gstate.last_producer_schedule_update = block_time; // 将参数区块时间赋值给全局状态变量：最后计划出块更新时间  
    auto idx = _producers.get_index<N(prototalvote)>(); // 获得producers表的索引prototalvote，该索引能够给producers表按照投票总数排序，详细分析见下一个部分。  
    std::vector< std::pair<eosio::producer_key,uint16_t> > top_producers; // 声明有效出块节点集合。  
    top_producers.reserve(21); // 定义有效出块节点集合的数量为21。  
    // 从prototalvote索引结果集中筛选出21个插入top_producers集合。这些生产者要满足是active的同时总票数大于0(最基本的校验)。  
    for ( auto it = idx.cbegin(); it != idx.cend() && top_producers.size() < 21 && 0 < it->total_votes && it->active(); ++it ) {  
      top_producers.emplace_back( std::pair<eosio::producer_key,uint16_t>({{it->owner, it->producer_key}, it->location}) );  
    }  
    // 如果有效出块集合的数量小于全局标志位：最后计划生产者数量(见下方)，则中断返回。(适用于总数不足21个节点的情况)  
    if ( top_producers.size() < _gstate.last_producer_schedule_size ) {  
      return;  
    }  
    // 根据名称为top_producers排序。  
    std::sort( top_producers.begin(), top_producers.end() );  
    // 新建producers集合，copy一份top_producers  
    std::vector<eosio::producer_key> producers; // 声明生产者集合  
    producers.reserve(top_producers.size()); // 将producers设置为与top_producers一样大小。  
    for( const auto& item : top_producers ) // 遍历copy元素  
      producers.push_back(item.first);  
    bytes packed_schedule = pack(producers); // 将超级节点集合打包成字节  
    if( set_proposed_producers( packed_schedule.data(),  packed_schedule.size() ) >= 0 ) { // 设置计划生产者，更新最后计划生产者数量  
      _gstate.last_producer_schedule_size = static_cast<decltype(_gstate.last_producer_schedule_size)>( top_producers.size() );  
    }  
} 

typedef eosio::multi_index< N(producers), producer_info,  
                               indexed_by<N(prototalvote), const_mem_fun<producer_info, double, &producer_info::by_votes> >  
                               >  producers_table;  

/** 
 * @brief 用于从X的base32编码字符串解释生成编译的uint64 t 
 *  
 * @param X - 代表名称的字符串 
* @return constexpr uint64_t - 64位无符整型值，可代表一个名称 
*/  
#define N(X) ::eosio::string_to_name(#X)  

template<uint64_t IndexName, typename Extractor>  
struct indexed_by {  
   enum constants { index_name   = IndexName };  
   typedef Extractor secondary_extractor_type;  
}; 

struct producer_info
{
   account_name owner;                                                        // producer账户名
   double total_votes = 0;                                                    // 当前producer的总投票数
   eosio::public_key producer_key;                                            // 当前producer的公钥
   bool is_active = true;                                                     // 当前producer是否有效
   std::string url;                                                           // 当前producer的介绍url，可以是官网
   uint32_t unpaid_blocks = 0;                                                // 未领奖励的区块数量
   uint64_t last_claim_time = 0;                                              // 上一次认领奖励的时间
   uint16_t location = 0;                                                     // 当前producer的位置
   uint64_t primary_key() const { return owner; }                             // producer_info结构体的主键，将被状态表producer_table作为第一索引。
   double by_votes() const { return is_active ? -total_votes : total_votes; } // 按投票(排序)，注意排序并不是在此实现，此方法只是为了区分，将失效producer的总票数置为其相反数
   bool active() const { return is_active; }                                  // 判断是否有效
   void deactivate()
   {
      producer_key = public_key();
      is_active = false;
   } // 将当前生产者设置为失效的动作。

   // 注意：明确序列化宏不是必要的，用在此处是为了提高编译效率
   EOSLIB_SERIALIZE(producer_info, (owner)(total_votes)(producer_key)(is_active)(url)(unpaid_blocks)(last_claim_time)(location))
};

/** 
 * @brief system合约的出块动作 
 *  
 * @param timestamp 时间戳 
 * @param producer  生产者 
 */  
void system_contract::onblock( block_timestamp timestamp, account_name producer ) {  
    using namespace eosio;  
    // 该动作是由eosio创世账户执行，要先校验是否有该账户权限。  
    require_auth(N(eosio));  
    // 当总激活抵押数小于最低激活抵押额时，停止动作。  
    if( _gstate.total_activated_stake < min_activated_stake )  
      return;  
    // 当预投票开始时，更新时间为当前时间。  
    if( _gstate.last_pervote_bucket_fill == 0 )  
      _gstate.last_pervote_bucket_fill = current_time();  
    // 在生产者集合中查询传入的生产者账号  
    auto prod = _producers.find(producer);  
    if ( prod != _producers.end() ) { // 成功查到结果  
      _gstate.total_unpaid_blocks++; // 全局未结算区块数加一  
      _producers.modify( prod, 0, [&](auto& p ) { // 当前生产者未结算数加一  
            p.unpaid_blocks++;  
      });  
    }  
    // 注意：每分钟只更新区块生产者一次，0.5秒更新一次区块时间。  
    if( timestamp.slot - gstate.last_producer_schedule_update.slot > 120 ){update_elected_producers( timestamp ); // 更新已入选生产节点，见上小节  
      // 账户名称拍卖工作的更新操作，注意：每天只能交易一次。  
      if( (timestamp.slot - _gstate.last_name_close.slot) > blocks_per_day ) {  
         name_bid_table bids(_self,_self); // 拍卖账户名的状态表实例。  
         auto idx = bids.get_index<N(highbid)>(); // 得到二级索引的结果集，按照出价高低排序。  
         auto highest = idx.begin();  
         /** 
          * @brief 判断是否符合拍卖结束条件。 
          * 条件包括： 
          * 1，状态表不为空 
          * 2，出价大于0 
          * 3，出价的时间在一秒钟之内 
          * 4，抵押激活时间大于0 
          * 5，当前时间至少超过抵押激活14天的时间 
          */  
         if( highest != idx.end() &&  
               highest->high_bid > 0 &&  
               highest->last_bid_time < (current_time() - useconds_per_day) && _gstate.thresh_activated_stake_time > 0 &&  
               (current_time() - _gstate.thresh_activated_stake_time) > 14 * useconds_per_day ) {  
                  _gstate.last_name_close = timestamp;// 记录成功交易时间  
                  idx.modify( highest, 0, [&]( auto& b ){  
                        b.high_bid = -b.high_bid; // 该笔拍卖报价已兑现，则置相反数，可作为记录的同时不参与其他有效报价。  
            });  
         }  
      }  
    }  
}  

typedef eosio::multi_index< N(namebids), name_bid,  
indexed_by<N(highbid), const_mem_fun<name_bid, uint64_t, &name_bid::by_high_bid > > >  name_bid_table;  

struct name_bid {
      account_name            newname;  
      account_name            high_bidder;  
      int64_t                 high_bid = 0;   // 若该项值为负数，则证明已获得拍卖名字，等待认领。  
      uint64_t                last_bid_time = 0;  
      auto     primary_key()const { return newname;  }   // 主键  
      uint64_t by_high_bid()const { return static_cast<uint64_t>(-high_bid); }  // 返回报价字段的值  
};  

/** 
 * @brief 初始化主币 
 *  
 * @param version 版本号 
 * @param core 初始化的主币对象 
 */  
void system_contract::init( unsigned_int version, symbol core ) {  
    require_auth( _self ); // 判断是否拥有合约主人身份。  
    eosio_assert( version.value == 0, "unsupported version for init action" ); // 对于初始化动作，版本号只能为0  
    auto itr = _rammarket.find(ramcore_symbol.raw()); // 在内存表中查找主币对象，如果已查到说明初始化操作已完成，退出当前进程
    eosio_assert( itr == _rammarket.end(), "system contract has already been initialized" );  
    // 此处调用了token的get_supply函数，获得主币供应量  
    auto system_token_supply   = eosio::token::get_supply(token_account, core.code() );  
    // 校验token的符号以及小数点精确位数是否一致。  
    eosio_assert( system_token_supply.symbol == core, "specified core symbol does not exist (precision mismatch)" );  
    // 校验主币的供应量是否大于0  
    eosio_assert( system_token_supply.amount > 0, "system token supply must be greater than 0" );  
    _rammarket.emplace( _self, [&]( auto& m ) { // 内存市场状态表新增数据  
      m.supply.amount = 100000000000000ll;  
      m.supply.symbol = ramcore_symbol;  
      m.base.balance.amount = int64_t(_gstate.free_ram());  
      m.base.balance.symbol = ram_symbol;  
      m.quote.balance.amount = system_token_supply.amount / 1000;  
      m.quote.balance.symbol = core;  
    });  
}  

/** 
 * @brief 账户名拍卖 
 *  
 * @param bidder 竞拍者 
 * @param newname 标的账户名 
 * @param bid 报价 
 */  
void system_contract::bidname( name bidder, name newname, asset bid ) {  
   require_auth( bidder ); // 校验竞拍者是否本人操作  
   // 校验标的账户名是否符合高级后缀。  
   eosio_assert( newname.suffix() == newname, "you can only bid on top-level suffix" );  
   eosio_assert( (bool)newname, "the empty name is not a valid account name to bid on" );//校验标的是否为空  
   eosio_assert( (newname.value & 0xFull) == 0, "13 character names are not valid account names to bid on" );//13个字符长度的标的不允许竞拍 
   // 常规账户长度为12位且不包含点，只有非常规账户才可以参与竞拍，即小于12个字符的，或者包含点的。  
   eosio_assert( (newname.value & 0x1F0ull) == 0, "accounts with 12 character names and no dots can be created without bidding required" ); 
   eosio_assert( !is_account( newname ), "account already exists" );// 校验标的账户是否已存在。  
   eosio_assert( bid.symbol == core_symbol(), "asset must be system token" );// 校验报价资产必须是主币  
   eosio_assert( bid.amount > 0, "insufficient bid" );// 校验报价必须正数  
   // 经过以上重重校验，可以进行实际拍卖环节。首先发起转账，将竞拍报价从竞拍者手中转账到eosio.names账户(该账户主管名称拍卖)  
   INLINE_ACTION_SENDER(eosio::token, transfer)(  
      token_account, { {bidder, active_permission} },  
      { bidder, names_account, bid, std::string("bid name ")+ newname.to_string() }  
   );  
   // 创建当前合约的name_bid_table状态表的实例bids  
   name_bid_table bids(_self, _self.value);  
   print( name{bidder}, " bid ", bid, " on ", name{newname}, "\n" );  
   auto current = bids.find( newname.value ); // 先查询是否已存在该标的的历史报价数据  
   if( current == bids.end() ) { // 如果不存在历史报价数据，则新建  
      bids.emplace( bidder, [&]( auto& b ) { // 添加该标的的首单竞拍相关字段到状态表。  
         b.newname = newname;  
         b.high_bidder = bidder;  
         b.high_bid = bid.amount;  
         b.last_bid_time = current_time_point();  
      });  
   } else { // 如果已经存在历史报价数据，则处理该标的的最高报价  
      // 历史最高报价high_bid已被置为负数，则说明该已成功交易，竞拍关闭。  
      eosio_assert( current->high_bid > 0, "this auction has already closed" );  
      // 此次新的报价必须高于该标的的历史最高报价的10%，这是竞拍规则。  
      eosio_assert( bid.amount - current->high_bid > (current->high_bid / 10), "must increase bid by 10%" );  
      // 如果该标的的当前最高报价已经是当前竞拍者本人，则不需要执行下面的逻辑。  
      eosio_assert( current->high_bidder != bidder, "account is already highest bidder" );  
      // 获得竞拍退款状态表big_refund_table的实例refunds_table，传入当前竞拍动作。  
      bid_refund_table refunds_table(_self, newname.value);  
      auto it = refunds_table.find( current->high_bidder.value );  
      if ( it != refunds_table.end() ) {  
         // 如果在竞拍退款表中找到当前竞拍价格相同的，则更新该条数据对象，增加退款金额为最高报价，以主币形式结算。  
         refunds_table.modify( it, same_payer, [&](auto& r) {  
               r.amount += asset( current->high_bid, core_symbol() );  
            });  
      } else {  
         // 如果未找到相同最高报价的，则新增一条数据对象，插入当前最高报价者以及报价价格。  
         refunds_table.emplace( bidder, [&](auto& r) {  
               r.bidder = current->high_bidder;  
               r.amount = asset( current->high_bid, core_symbol() );  
            });  
      }  
      // 打包交易，插入bidrefund动作，传入最高报价者以及标的。  
      transaction t;  
      t.actions.emplace_back( permission_level{_self, active_permission},  
                              _self, "bidrefund"_n,  
                              std::make_tuple( current->high_bidder, newname )  
      );  
      t.delay_sec = 0;// 定义延迟时间  
      // 定义延迟id  
      uint128_t deferred_id = (uint128_t(newname.value) << 64) | current->high_bidder.value;  
      cancel_deferred( deferred_id ); // 按延迟id取消延迟交易  
      t.send( deferred_id, bidder ); // 发送延迟交易  
      // 最后修改name_bid_table状态表的实例bids，将当前竞拍动作更新到该标的对象，包括最高报价者、最高报价以及时间。  
      bids.modify( current, bidder, [&]( auto& b ) {  
         b.high_bidder = bidder;  
         b.high_bid = bid.amount;  
         b.last_bid_time = current_time_point();  
      });  
   }  
} 

/** 
 * @brief 创建账户，包括资源管理以及名称竞拍的逻辑。 
 *  
 * @param creator 创建者 
 * @param newact 被创建的账户，如果包含点“.”，则其创建者也必须包含相同后缀。 
 * @param owner owner权限 
 * @param active active权限 
 */  
void native::newaccount( name              creator,  
                         name              newact,  
                         ignore<authority> owner,  
                         ignore<authority> active ) {  
    if( creator != _self ) { // 创建者不能是当前合约账户。  
      uint64_t tmp = newact.value >> 4; // 将新账户名由字符转为无符号int  
      bool has_dot = false;// 定义标志位，是否包含点“.”  
      for( uint32_t i = 0; i < 12; ++i ) {// 遍历12次，因为名称最长12个字符  
         has_dot |= !(tmp & 0x1f); // 检查是否有点“.”存在，同时还可以检查账户的长度是否少于12位，有则更新has_dot标志位为true。  
         tmp >>= 5; // 移到下一位检查  
      }  
      if( has_dot ) { // 非常规账户  
         auto suffix = newact.suffix(); // 后缀  
         if( suffix == newact ) { // 创建者的后缀必须相同  
            // 在竞拍状态表中寻找创建者拥有的非常规账户，是否包含待创建账户  
            name_bid_table bids(_self, _self.value);   
            auto current = bids.find( newact.value );  
            eosio_assert( current != bids.end(), "no active bid for name");
            // 校验当前待创建账户作为竞拍标的，其最高竞拍价是否是创建者报出的。  
            eosio_assert( current->high_bidder == creator, "only highest bidder can claim" );  
            // 如果high_bid字段不是负数，说明竞拍未结束，该非常规账户还不属于创建者。  
            eosio_assert( current->high_bid < 0, "auction for name is not closed yet" );  
            bids.erase( current ); // 通过以上校验，该竞拍标的属于创建者，创建者创建成功，删除标的历史对象。  
         } else {  
            eosio_assert( creator == suffix, "only suffix may create this account" );  
         }  
      }  
    }  
    // 为新用户分配资源，初始化添加到用户资源状态表  
    user_resources_table  userres( _self, newact.value);   
    userres.emplace( newact, [&]( auto& res ) {   
      res.owner = newact;  
      res.net_weight = asset( 0, system_contract::get_core_symbol() );  
      res.cpu_weight = asset( 0, system_contract::get_core_symbol() );  
    });  
    set_resource_limits( newact.value, 0, 0, 0 );  
}