摘要：在主網(wǎng)上玩耍的小伙伴們肯定遇到過區(qū)塊回滾導致自己的交易沒有上鏈。這種情況讓有些人誤以為區(qū)塊回滾會丟棄交易。其實區(qū)塊回滾并不是導致交易沒上鏈的主要原因，主要原因是交易過期了才導致交易被丟棄。源碼解析我們來看看區(qū)塊生產(chǎn)時是如何丟棄過期交易的。

????在主網(wǎng)上玩耍的小伙伴們肯定遇到過區(qū)塊回滾導致自己的交易沒有上鏈。這種情況讓有些人誤以為區(qū)塊回滾會丟棄交易。 其實區(qū)塊回滾并不是導致交易沒上鏈的主要原因， 主要原因是交易過期了才導致交易被丟棄。

 每個交易是會被廣播到全網(wǎng)每個節(jié)點上面的( ps: 當然傳播過程中過期的話，當我沒說哈 )，假如出塊節(jié)點 A 打包了 trx a, 但此時出塊節(jié)點 B 沒接受到 A 的打包塊，他也開始打包了，那么他也包含了該 trx a 并會將他打包( ps: 當然也有例外情況，那就是 出塊節(jié)點 B 接收到 trx a 時，他就過期了，所以還沒打包就丟棄他，或者還沒傳遞到出塊節(jié)點 B， 但會抵達下個節(jié)點 C D E， 但情況相似，就不另外說明了 )。但如果 a 的過期時間設(shè)置過短，導致出塊節(jié)點 B 打包時發(fā)現(xiàn)他過期了，就會丟棄他。 這便是交易沒上鏈的原因。

 我們來看看區(qū)塊生產(chǎn)時是如何丟棄過期交易的。區(qū)塊生產(chǎn)的流程 區(qū)塊的分叉處理可以看下我之前的文章。這里生產(chǎn)區(qū)塊以及回滾的細節(jié)就不贅述了。

區(qū)塊打包時，會將 pending block 里已經(jīng)執(zhí)行成功了的 trx 另外存起來， 并初始化 pending block。 等到打包的時候會再去執(zhí)行一次這些 trx , 咦，為什么要重新執(zhí)行一遍浪費資源，因為這些 trx 都是在區(qū)塊打包之前執(zhí)行的，鬼知道過期了沒有 =，=。

以下是交易被殘忍丟棄的過程：

// controller.cpp
// 將 pending block 的 trx 保存到 unapplied_transaction
void abort_block() {
if( pending ) {

  if ( read_mode == db_read_mode::SPECULATIVE ) {
     for( const auto& t : pending->_pending_block_state->trxs )
        unapplied_transactions[t->signed_id] = t;
  }
  pending.reset();

}
}

// producer_plugin.cpp
producer_plugin_impl::start_block_result producer_plugin_impl::start_block(bool &last_block) {
// ...

try {

  // ...

  // 將 pending block 里面的 trx 保存了 unapplied_transaction
  chain.abort_block();
  // 初始化 pending block
  chain.start_block(block_time, blocks_to_confirm);

} FC_LOG_AND_DROP();

const auto& pbs = chain.pending_block_state();
if (pbs) {

  // ...


  // _persistent_transactions 是指通過該節(jié)點的 http 端口 push_transaction 推送過來的 trx
  // remove all persisted transactions that have now expired
  auto& persisted_by_id = _persistent_transactions.get();
  auto& persisted_by_expiry = _persistent_transactions.get();
  if (!persisted_by_expiry.empty()) {
     int num_expired_persistent = 0;
     int orig_count = _persistent_transactions.size();

     // 丟棄過期交易
     while(!persisted_by_expiry.empty() && persisted_by_expiry.begin()->expiry <= pbs->header.timestamp.to_time_point()) {
        auto const& txid = persisted_by_expiry.begin()->trx_id;
        if (_pending_block_mode == pending_block_mode::producing) {
           fc_dlog(_trx_trace_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} is EXPIRING PERSISTED tx: ${txid}",
                   ("block_num", chain.head_block_num() + 1)
                   ("prod", chain.pending_block_state()->header.producer)
                   ("txid", txid));
        } else {
           fc_dlog(_trx_trace_log, "[TRX_TRACE] Speculative execution is EXPIRING PERSISTED tx: ${txid}",
                   ("txid", txid));
        }

        persisted_by_expiry.erase(persisted_by_expiry.begin());
        num_expired_persistent++;
     }

     fc_dlog(_log, "Processed ${n} persisted transactions, Expired ${expired}",
            ("n", orig_count)
            ("expired", num_expired_persistent));
  }

  try {
     size_t orig_pending_txn_size = _pending_incoming_transactions.size();

     // Processing unapplied transactions...
     // 當節(jié)點不是 出塊節(jié)點并且 也沒有通過該節(jié)點推送的 trx, 則 unapplied_transaction 無意義
     // 因為你不需要打包區(qū)塊， 也沒有 trx 需要廣播出去。
     if (_producers.empty() && persisted_by_id.empty()) {
        // if this node can never produce and has no persisted transactions,
        // there is no need for unapplied transactions they can be dropped
        chain.drop_all_unapplied_transactions();
     } else {
        std::vector apply_trxs;
        { // derive appliable transactions from unapplied_transactions and drop droppable transactions
           auto unapplied_trxs = chain.get_unapplied_transactions();
           apply_trxs.reserve(unapplied_trxs.size());

           auto calculate_transaction_category = [&](const transaction_metadata_ptr& trx) {
              if (trx->packed_trx.expiration() < pbs->header.timestamp.to_time_point()) {
                 return tx_category::EXPIRED;
              } else if (persisted_by_id.find(trx->id) != persisted_by_id.end()) {
                 return tx_category::PERSISTED;
              } else {
                 return tx_category::UNEXPIRED_UNPERSISTED;
              }
           };


           // 將沒過期的放進 apply_trxs， 過期的丟棄掉。
           for (auto& trx: unapplied_trxs) {
              auto category = calculate_transaction_category(trx);
              if (category == tx_category::EXPIRED || (category == tx_category::UNEXPIRED_UNPERSISTED && _producers.empty())) {
                 if (!_producers.empty()) {
                    fc_dlog(_trx_trace_log, "[TRX_TRACE] Node with producers configured is dropping an EXPIRED transaction that was PREVIOUSLY ACCEPTED : ${txid}",
                           ("txid", trx->id));
                 }
                 chain.drop_unapplied_transaction(trx);
              } else if (category == tx_category::PERSISTED || (category == tx_category::UNEXPIRED_UNPERSISTED && _pending_block_mode == pending_block_mode::producing)) {
                 apply_trxs.emplace_back(std::move(trx));
              }
           }
        }

        if (!apply_trxs.empty()) {
           // 執(zhí)行 trx， 成功的 emplace_back 進 pending block
        }
     }

     // ...
     // 執(zhí)行 deffered transaction
     // 和執(zhí)行 初始化 pending block 時推送進來的 transcation ( 因為初始化時，pending block 不能存 trx, 所以先另外存起來)

}

return start_block_result::failed;
}

回滾并不會丟棄 trx， 只會導致 trx 延后打包，以致于 trx 可能過期被丟棄。
設(shè)置過期時間時，時間跨度應該足夠 2 個 BP 出完塊，這樣即使 B 沒接收到 A 的區(qū)塊，但 trx 不會因為過期而被 B 丟棄，當然還要大致估算你的 trx 廣播到出塊節(jié)點的時間。

有任何疑問或者想交流的朋友可以加 EOS LIVE 小助手，備注 eos開發(fā)者拉您進 EOS LIVE DAPP 開發(fā)者社區(qū)微信群哦。
圖片描述

?原文鏈接：https://eos.live/detail/18931