eos代码阅读笔记05- 事务transaction

      数据库的事务定义：事务（Transaction）是并发控制的单位，是用户定义的一个操作序列。这些操作要么都做，要么都不做，是一个不可分割的工作单位。

      eos的transaction很像数据库的事务。用事务完成交易，账号/权限的创建。

事务中的对象继承关系

transaction_header （头）-> transaction -> signed_transaction（签名） -> deferred_transaction（推迟）

事务头对象 /eos/libraries/chain/include/eosio/chain/transaction.hpp

 /**
    *  The transaction header contains the fixed-sized data
    *  associated with each transaction. It is separated from
    *  the transaction body to facilitate partial parsing of
    *  transactions without requiring dynamic memory allocation.
    *事务头包含与每个事务相关联的固定大小的数据。它与事务体分离，以便于事务的部分解析，而不需要动态内存分配。
    *  All transactions have an expiration time after which they
    *  may no longer be included in the blockchain. Once a block
    *  with a block_header::timestamp greater than expiration is
    *  deemed irreversible, then a user can safely trust the transaction
    *  will never be included.
    *所有事务都有一个到期时间，在此之后它们可能不再被包含在BROG链中。一旦一个带有BuffixHead的块：：大于到期的时间戳被认为是不可逆的，那么用户可以安全地信任该事务将永远不被包括在内。

    *  Each region is an independent blockchain, it is included as routing
    *  information for inter-blockchain communication. A contract in this
    *  region might generate or authorize a transaction intended for a foreign
    *  region.每个区域是一个独立的块链，它被作为路由信息用于链间链通信。该地区的合同可能产生或授权旨在为外国地区进行的交易。
    */
   struct transaction_header {
      time_point_sec         expiration;   ///< the time at which a transaction expires 交易到期的时间
      uint16_t               ref_block_num       = 0U; ///< specifies a block num in the last 2^16 blocks.指定到上一个块
      uint32_t               ref_block_prefix    = 0UL; ///< specifies the lower 32 bits of the blockid at get_ref_blocknum 指定块的较低的32位。
      fc::unsigned_int       max_net_usage_words = 0UL; /// upper limit on total network bandwidth (in 8 byte words) billed for this transaction 8字节的总网络带宽上线
      uint8_t                max_cpu_usage_ms    = 0; /// upper limit on the total CPU time billed for this transaction 此交易的总CPU时间上限
      fc::unsigned_int       delay_sec           = 0UL; /// number of seconds to delay this transaction for during which it may be canceled.延迟该事务的秒数，在此期间可以取消该事务。

事务对象

  /**
    *  A transaction consits of a set of messages which must all be applied or
    *  all are rejected. These messages have access to data within the given
    *  read and write scopes.事务必须包含一组消息，这些消息必须全部应用或全部被拒绝。这些消息可以访问给定的读写范围内的数据。
    */
   struct transaction : public transaction_header {
      vector         context_free_actions;上下文-自由动作
      vector         actions;操作，一个事务可以有多个操作
      extensions_type        transaction_extensions;扩展型事务

      transaction_id_type        id()const;
      digest_type                sig_digest( const chain_id_type& chain_id, const vector& cfd = vector() )const;
      flat_set  get_signature_keys( const vector& signatures,
                                                     const chain_id_type& chain_id,
                                                     const vector& cfd = vector(),
                                                     bool allow_duplicate_keys = false )const;

      uint32_t total_actions()const { return context_free_actions.size() + actions.size(); }
      account_name first_authorizor()const {
         for( const auto& a : actions ) {
            for( const auto& u : a.authorization )
               return u.actor;
         }
         return account_name();
      }

   };

签名

 struct signed_transaction : public transaction
   {
      signed_transaction() = default;
//      signed_transaction( const signed_transaction& ) = default;
//      signed_transaction( signed_transaction&& ) = default;
      signed_transaction( transaction&& trx, const vector& signatures, const vector& context_free_data)
      : transaction(std::move(trx))
      , signatures(signatures)
      , context_free_data(context_free_data)
      {
      }

      vector    signatures;
      vector             context_free_data; ///< for each context-free action, there is an entry here

      const signature_type&     sign(const private_key_type& key, const chain_id_type& chain_id);
      signature_type            sign(const private_key_type& key, const chain_id_type& chain_id)const;
      flat_set get_signature_keys( const chain_id_type& chain_id, bool allow_duplicate_keys = false )const;
   };

延迟执行

/**
    *  When a transaction is generated it can be scheduled to occur
    *  in the future. It may also fail to execute for some reason in
    *  which case the sender needs to be notified. When the sender
    *  sends a transaction they will assign it an ID which will be
    *  passed back to the sender if the transaction fails for some
    *  reason.
当生成事务时，它可以被安排在将来发生。它也可能由于某种原因而无法执行，在这种情况下，需要通知发送方。
当发送方发送一个事务时，如果某个原因由于事务失败，他们会将ID分配给发送方。
    */
   struct deferred_transaction : public signed_transaction
   {
      uint128_t      sender_id; /// ID assigned by sender of generated, accessible via WASM api when executing normal or error
                                   当执行正常或错误时，由发送者通过WASM API生成、可访问的ID
      account_name   sender; /// receives error handler callback 接收错误处理回调
      account_name   payer;
      time_point_sec execute_after; /// delayed execution 延迟执行

操作，事务中的操作

/**
    *  An action is performed by an actor, aka an account. It may
    *  be created explicitly and authorized by signatures or might be
    *  generated implicitly by executing application code.
    *一个动作是由一个演员来完成的，也就是一个账户。它可以显式创建并由签名授权，或者可以通过执行应用程序代码隐式地生成。
    *  This follows the design pattern of React Flux where actions are
    *  named and then dispatched to one or more action handlers (aka stores).
    *  In the context of eosio, every action is dispatched to the handler defined
    *  by account 'scope' and function 'name', but the default handler may also
    *  forward the action to any number of additional handlers. Any application
    *  can write a handler for "scope::name" that will get executed if and only if
    *  this action is forwarded to that application.
    *这遵循反应磁通的设计模式，其中动作被命名，然后被调度到一个或多个动作处理器（AKA存储）。
在EOSIO的上下文中，每个动作都被分配到由帐户“范围”和函数“名称”定义的处理程序中，但默认处理程序也可以将操作转发到任意数量的附加处理程序。
任何应用程序都可以编写一个“范围：：名称”的处理程序，当且仅当此操作被转发到该应用程序时，它将被执行。
    *  Each action may require the permission of specific actors. Actors can define
    *  any number of permission levels. The actors and their respective permission
    *  levels are declared on the action and validated independently of the executing
    *  application code. An application code will check to see if the required authorization
    *  were properly declared when it executes.
每一个动作都需要特定演员的许可。参与者可以定义任意数量的权限级别。
演员及其各自许可在操作中声明级别，并独立于执行的应用程序代码进行验证。
应用程序代码将检查在执行时是否正确声明了所需的授权。
 */
   struct action {
      account_name               account;
      action_name                name;
      vector   authorization;
      bytes                      data;

      action(){}