Implement DISABLE_DEFERRED_TRXS_STAGE_1 and DISABLE_DEFERRED_TRXS_STAGE_2 protocol features

.cicd/defaults.json

@@ -4,6 +4,6 @@
        "prerelease":false
     },
     "eossystemcontracts":{
-       "ref":"release/3.1"
+       "ref":"main"
     }
  }

libraries/chain/apply_context.cpp

@@ -423,6 +423,11 @@ void apply_context::execute_context_free_inline( action&& a ) {
 
 
 void apply_context::schedule_deferred_transaction( const uint128_t& sender_id, account_name payer, transaction&& trx, bool replace_existing ) {
+   // no-op after DISABLE_DEFERRED_TRXS_STAGE_1 is activated
+   if( control.is_builtin_activated( builtin_protocol_feature_t::disable_deferred_trxs_stage_1 ) ) {
+      return;
+   }
+
    EOS_ASSERT( !trx_context.is_read_only(), transaction_exception, "cannot schedule a deferred transaction from within a readonly transaction" );
    EOS_ASSERT( trx.context_free_actions.size() == 0, cfa_inside_generated_tx, "context free actions are not currently allowed in generated transactions" );
 
@@ -624,6 +629,11 @@ void apply_context::schedule_deferred_transaction( const uint128_t& sender_id, a
 }
 
 bool apply_context::cancel_deferred_transaction( const uint128_t& sender_id, account_name sender ) {
+   // no-op after DISABLE_DEFERRED_TRXS_STAGE_1 is activated
+   if( control.is_builtin_activated( builtin_protocol_feature_t::disable_deferred_trxs_stage_1 ) ) {
+      return false;
+   }
+
    EOS_ASSERT( !trx_context.is_read_only(), transaction_exception, "cannot cancel a deferred transaction from within a readonly transaction" );
    auto& generated_transaction_idx = db.get_mutable_index<generated_transaction_multi_index>();
    const auto* gto = db.find<generated_transaction_object,by_sender_id>(boost::make_tuple(sender, sender_id));

libraries/chain/controller.cpp

@@ -339,6 +339,8 @@ struct controller_impl {
       set_activation_handler<builtin_protocol_feature_t::get_block_num>();
       set_activation_handler<builtin_protocol_feature_t::crypto_primitives>();
       set_activation_handler<builtin_protocol_feature_t::bls_primitives>();
+      set_activation_handler<builtin_protocol_feature_t::disable_deferred_trxs_stage_1>();
+      set_activation_handler<builtin_protocol_feature_t::disable_deferred_trxs_stage_2>();
 
       self.irreversible_block.connect([this](const block_state_ptr& bsp) {
          wasmif.current_lib(bsp->block_num);
@@ -1302,8 +1304,11 @@ struct controller_impl {
 
       fc::datastream<const char*> ds( gtrx.packed_trx.data(), gtrx.packed_trx.size() );
 
-      EOS_ASSERT( gtrx.delay_until <= self.pending_block_time(), transaction_exception, "this transaction isn't ready",
-                 ("gtrx.delay_until",gtrx.delay_until)("pbt",self.pending_block_time())          );
+      // check delay_until only before disable_deferred_trxs_stage_1 is activated.
+      if( !self.is_builtin_activated( builtin_protocol_feature_t::disable_deferred_trxs_stage_1 ) ) {
+         EOS_ASSERT( gtrx.delay_until <= self.pending_block_time(), transaction_exception, "this transaction isn't ready",
+                    ("gtrx.delay_until",gtrx.delay_until)("pbt",self.pending_block_time()) );
+      }
 
       signed_transaction dtrx;
       fc::raw::unpack(ds,static_cast<transaction&>(dtrx) );
@@ -1312,8 +1317,11 @@ struct controller_impl {
                                                           transaction_metadata::trx_type::scheduled );
       trx->accepted = true;
 
+      // after disable_deferred_trxs_stage_1 is activated, a deferred
+      // transaction can be retired as expired at any time regardless of
+      // whether its delay_until or expiration times have been reached.
       transaction_trace_ptr trace;
-      if( gtrx.expiration < self.pending_block_time() ) {
+      if( self.is_builtin_activated( builtin_protocol_feature_t::disable_deferred_trxs_stage_1 ) || gtrx.expiration < self.pending_block_time() ) {
          trace = std::make_shared<transaction_trace>();
          trace->id = gtrx.trx_id;
          trace->block_num = self.head_block_num() + 1;
@@ -3835,6 +3843,20 @@ void controller_impl::on_activation<builtin_protocol_feature_t::bls_primitives>(
    } );
 }
 
+template<>
+void controller_impl::on_activation<builtin_protocol_feature_t::disable_deferred_trxs_stage_1>() {
+   ; // nothing to do at activation
+}
+
+template<>
+void controller_impl::on_activation<builtin_protocol_feature_t::disable_deferred_trxs_stage_2>() {
+   const auto& idx = db.get_index<generated_transaction_multi_index, by_trx_id>();
+   // remove all deferred trxs and refund their payers
+   for( auto itr = idx.begin(); itr != idx.end(); itr = idx.begin() ) {
+      remove_scheduled_transaction(*itr);
+   }
+}
+
 /// End of protocol feature activation handlers
 
 } } /// eosio::chain

libraries/chain/include/eosio/chain/protocol_feature_manager.hpp

@@ -36,6 +36,8 @@ enum class builtin_protocol_feature_t : uint32_t {
    crypto_primitives = 19,
    get_block_num = 20,
    bls_primitives = 21,
+   disable_deferred_trxs_stage_1 = 22,
+   disable_deferred_trxs_stage_2 = 23,
    reserved_private_fork_protocol_features = 500000,
 };
 

libraries/chain/protocol_feature_manager.cpp

@@ -272,6 +272,40 @@ Adds new cryptographic host functions
 */
             {}
          } )
+         (  builtin_protocol_feature_t::disable_deferred_trxs_stage_1, builtin_protocol_feature_spec{
+            "DISABLE_DEFERRED_TRXS_STAGE_1",
+            fc::variant("8c909017896bab2e294978e9e5cbcb804fa882a52587702ee65b05cf67d59222").as<digest_type>(),
+            // SHA256 hash of the raw message below within the comment delimiters (do not modify message below).
+/*
+Builtin protocol feature: DISABLE_DEFERRED_TRXS_STAGE_1
+
+Once this first disabling deferred transactions protocol feature is activated,
+the behavior of the send_deferred and cancel_deferred host functions and
+canceldelay native action changes so that they become no-ops. In addition,
+a block will expire deferred transactions until it reaches the hard-coded
+wall-clock deadline for that block; any block that retires a deferred
+transaction with a status other than expired is invalid. Also, a deferred
+transaction can be retired as expired at any time regardless of whether its
+delay_until or expiration times have been reached.
+*/
+            {}
+         } )
+         (  builtin_protocol_feature_t::disable_deferred_trxs_stage_2, builtin_protocol_feature_spec{
+            "DISABLE_DEFERRED_TRXS_STAGE_2",
+            fc::variant("dd53e40a1832078eadec7817f300c2ad20e6d170ecd8103f88b02be944aa3d46").as<digest_type>(),
+            // SHA256 hash of the raw message below within the comment delimiters (do not modify message below).
+/*
+Builtin protocol feature: DISABLE_DEFERRED_TRXS_STAGE_2
+Depends on: DISABLE_DEFERRED_TRXS_STAGE_1
+
+On activation of this second disabling deferred transactions protocol feature,
+its activation handler iterates through any remaining deferred transactions
+to refund the RAM paid for the sender of that deferred transaction and to delete
+the deferred transaction from the state. All deferred transactions are cleared
+out within the activation handler.
+*/
+            {builtin_protocol_feature_t::disable_deferred_trxs_stage_1}
+         } )
    ;
 
 

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

@@ -64,7 +64,8 @@ namespace eosio { namespace testing {
       preactivate_feature_only,
       preactivate_feature_and_new_bios,
       old_wasm_parser,
-      full
+      full,
+      full_but_disable_deferrd_trx
    };
 
    std::ostream& operator<<(std::ostream& os, setup_policy p);
@@ -386,6 +387,8 @@ namespace eosio { namespace testing {
          void preactivate_protocol_features(const vector<digest_type> feature_digests);
          void preactivate_builtin_protocol_features(const std::vector<builtin_protocol_feature_t>& features);
          void preactivate_all_builtin_protocol_features();
+         void preactivate_all_but_disable_deferrd_trx();
+         void preactivate_all_builtin_protocol_features_common(const std::vector<builtin_protocol_feature_t>& ordered_builtins);
 
          static genesis_state default_genesis() {
             genesis_state genesis;
@@ -512,6 +515,12 @@ namespace eosio { namespace testing {
       bool validate() { return true; }
    };
 
+   class tester_no_disable_deferrd_trx : public tester {
+   public:
+      tester_no_disable_deferrd_trx(): tester(setup_policy::full_but_disable_deferrd_trx) {
+      }
+   };
+
    class validating_tester : public base_tester {
    public:
       virtual ~validating_tester() {
@@ -657,6 +666,12 @@ namespace eosio { namespace testing {
       bool                     skip_validate = false;
    };
 
+   class validating_tester_no_disable_deferrd_trx : public validating_tester {
+   public:
+      validating_tester_no_disable_deferrd_trx(): validating_tester({}, nullptr, setup_policy::full_but_disable_deferrd_trx) {
+      }
+   };
+
    /**
     * Utility predicate to check whether an fc::exception message is equivalent to a given string
     */

libraries/testing/tester.cpp

@@ -265,11 +265,16 @@ namespace eosio { namespace testing {
             set_bios_contract();
             break;
          }
-         case setup_policy::full: {
+         case setup_policy::full:
+         case setup_policy::full_but_disable_deferrd_trx: {
             schedule_preactivate_protocol_feature();
             produce_block();
             set_before_producer_authority_bios_contract();
-            preactivate_all_builtin_protocol_features();
+            if( policy == setup_policy::full ) {
+               preactivate_all_builtin_protocol_features();
+            } else {
+               preactivate_all_but_disable_deferrd_trx();
+            }
             produce_block();
             set_bios_contract();
             break;
@@ -1197,7 +1202,8 @@ namespace eosio { namespace testing {
       preactivate_protocol_features(features);
    }
 
-   void base_tester::preactivate_all_builtin_protocol_features() {
+
+   void base_tester::preactivate_all_builtin_protocol_features_common(const std::vector<builtin_protocol_feature_t>& ordered_builtins) {
       const auto& pfm = control->get_protocol_feature_manager();
       const auto& pfs = pfm.get_protocol_feature_set();
       const auto current_block_num  =  control->head_block_num() + (control->is_building_block() ? 1 : 0);
@@ -1225,11 +1231,6 @@ namespace eosio { namespace testing {
          preactivations.emplace_back( feature_digest );
       };
 
-      std::vector<builtin_protocol_feature_t> ordered_builtins;
-      for( const auto& f : builtin_protocol_feature_codenames ) {
-         ordered_builtins.push_back( f.first );
-      }
-      std::sort( ordered_builtins.begin(), ordered_builtins.end() );
       for( const auto& f : ordered_builtins ) {
          auto digest = pfs.get_builtin_digest( f);
          if( !digest ) continue;
@@ -1239,6 +1240,35 @@ namespace eosio { namespace testing {
       preactivate_protocol_features( preactivations );
    }
 
+   void base_tester::preactivate_all_builtin_protocol_features() {
+      std::vector<builtin_protocol_feature_t> ordered_builtins;
+      for( const auto& f : builtin_protocol_feature_codenames ) {
+         ordered_builtins.push_back( f.first );
+      }
+      std::sort( ordered_builtins.begin(), ordered_builtins.end() );
+
+      preactivate_all_builtin_protocol_features_common( ordered_builtins );
+   }
+
+   void base_tester::preactivate_all_but_disable_deferrd_trx() {
+      std::vector<builtin_protocol_feature_t> ordered_builtins;
+      for( const auto& f : builtin_protocol_feature_codenames ) {
+         // Before deferred trxs feature is fully disabled, existing tests involving
+         // deferred trxs need to be exercised to make sure existing behaviors are
+         // maintained. Excluding DISABLE_DEFERRED_TRXS_STAGE_1 and DISABLE_DEFERRED_TRXS_STAGE_2
+         // from full protocol feature list such that existing tests can run.
+         std::string codename = f.second.codename;
+         if( codename == "DISABLE_DEFERRED_TRXS_STAGE_1" || codename == "DISABLE_DEFERRED_TRXS_STAGE_2" ) {
+            continue;
+         }
+
+         ordered_builtins.push_back( f.first );
+      }
+      std::sort( ordered_builtins.begin(), ordered_builtins.end() );
+
+      preactivate_all_builtin_protocol_features_common( ordered_builtins );
+   }
+
    tester::tester(const std::function<void(controller&)>& control_setup, setup_policy policy, db_read_mode read_mode) {
       auto def_conf            = default_config(tempdir);
       def_conf.first.read_mode = read_mode;

plugins/producer_plugin/producer_plugin.cpp

@@ -373,7 +373,7 @@ class producer_plugin_impl : public std::enable_shared_from_this<producer_plugin
    bool     remove_expired_trxs(const fc::time_point& deadline);
    bool     remove_expired_blacklisted_trxs(const fc::time_point& deadline);
    bool     process_unapplied_trxs(const fc::time_point& deadline);
-   void     retire_expired_deferred_trxs(const fc::time_point& deadline);
+   bool     retire_deferred_trxs(const fc::time_point& deadline);
    bool     process_incoming_trxs(const fc::time_point& deadline, unapplied_transaction_queue::iterator& itr);
 
    struct push_result {
@@ -1948,9 +1948,15 @@ producer_plugin_impl::start_block_result producer_plugin_impl::start_block() {
             if (!process_unapplied_trxs(preprocess_deadline))
                return start_block_result::exhausted;
 
-            // Hard-code the deadline to retire expired deferred trxs to 10ms
-            auto deferred_trxs_deadline = std::min<fc::time_point>(preprocess_deadline, fc::time_point::now() + fc::milliseconds(10));
-            retire_expired_deferred_trxs(deferred_trxs_deadline);
+            // after DISABLE_DEFERRED_TRXS_STAGE_2 is activated,
+            // no deferred trxs are allowed to be retired
+            if (!chain.is_builtin_activated( builtin_protocol_feature_t::disable_deferred_trxs_stage_2) ) {
+               // Hard-code the deadline to retire expired deferred trxs to 10ms
+               auto deferred_trxs_deadline = std::min<fc::time_point>(preprocess_deadline, fc::time_point::now() + fc::milliseconds(10));
+               if (!retire_deferred_trxs(deferred_trxs_deadline)) {
+                  return start_block_result::failed;
+               }
+            }
          }
 
          repost_exhausted_transactions(preprocess_deadline);
@@ -2293,7 +2299,7 @@ bool producer_plugin_impl::process_unapplied_trxs(const fc::time_point& deadline
    return !exhausted;
 }
 
-void producer_plugin_impl::retire_expired_deferred_trxs(const fc::time_point& deadline) {
+bool producer_plugin_impl::retire_deferred_trxs(const fc::time_point& deadline) {
    int   num_applied    = 0;
    int   num_failed     = 0;
    int   num_processed  = 0;
@@ -2306,8 +2312,10 @@ void producer_plugin_impl::retire_expired_deferred_trxs(const fc::time_point& de
    auto               expired_itr         = expired_idx.begin();
 
    while (expired_itr != expired_idx.end()) {
-      if (expired_itr->expiration >= pending_block_time) {
-         break; // not expired yet
+      // * Before disable_deferred_trxs_stage_1 is activated, retire only expired deferred trxs.
+      // * After disable_deferred_trxs_stage_1, retire any deferred trxs in any order
+      if (!chain.is_builtin_activated( builtin_protocol_feature_t::disable_deferred_trxs_stage_1) && expired_itr->expiration >= pending_block_time) { // before stage_1 and not expired yet
+         break;
       }
 
       if (exhausted || deadline <= fc::time_point::now()) {
@@ -2374,9 +2382,14 @@ void producer_plugin_impl::retire_expired_deferred_trxs(const fc::time_point& de
    }
 
    if (expired_size > 0) {
-      fc_dlog(_log, "Processed ${m} of ${n} expired scheduled transactions, Applied ${applied}, Failed/Dropped ${failed}",
+      fc_dlog(_log, "Processed ${m} of ${n} scheduled transactions, Applied ${applied}, Failed/Dropped ${failed}",
               ("m", num_processed)("n", expired_size)("applied", num_applied)("failed", num_failed));
    }
+
+   if (chain.is_builtin_activated( builtin_protocol_feature_t::disable_deferred_trxs_stage_1) && num_failed > 0) {
+      return false;
+   }
+   return true;
 }
 
 bool producer_plugin_impl::process_incoming_trxs(const fc::time_point& deadline, unapplied_transaction_queue::iterator& itr) {

unittests/api_tests.cpp

@@ -1287,7 +1287,7 @@ BOOST_FIXTURE_TEST_CASE(checktime_grow_memory, validating_tester) { try {
                                deadline_exception, is_deadline_exception );
 } FC_LOG_AND_RETHROW() }
 
-BOOST_FIXTURE_TEST_CASE(checktime_hashing_fail, validating_tester) { try {
+BOOST_FIXTURE_TEST_CASE(checktime_hashing_fail, validating_tester_no_disable_deferrd_trx) { try {
 	produce_blocks(2);
 	create_account( "testapi"_n );
 	produce_blocks(10);
@@ -1362,7 +1362,7 @@ BOOST_FIXTURE_TEST_CASE(checktime_start, validating_tester) try {
 /*************************************************************************************
  * transaction_tests test case
  *************************************************************************************/
-BOOST_FIXTURE_TEST_CASE(transaction_tests, validating_tester) { try {
+BOOST_FIXTURE_TEST_CASE(transaction_tests, validating_tester_no_disable_deferrd_trx) { try {
    produce_blocks(2);
    create_account( "testapi"_n );
    produce_blocks(100);
@@ -1574,8 +1574,8 @@ BOOST_AUTO_TEST_CASE(inline_action_objective_limit) { try {
 
 BOOST_AUTO_TEST_CASE(deferred_inline_action_limit) { try {
    const uint32_t _4k = 4 * 1024;
-   tester chain(setup_policy::full, db_read_mode::HEAD, {_4k + 100});
-   tester chain2(setup_policy::full, db_read_mode::HEAD, {_4k + 100});
+   tester chain(setup_policy::full_but_disable_deferrd_trx, db_read_mode::HEAD, {_4k + 100});
+   tester chain2(setup_policy::full_but_disable_deferrd_trx, db_read_mode::HEAD, {_4k + 100});
    signed_block_ptr block;
    for (int n=0; n < 2; ++n) {
       block = chain.produce_block();
@@ -1613,7 +1613,7 @@ BOOST_AUTO_TEST_CASE(deferred_inline_action_limit) { try {
 
 } FC_LOG_AND_RETHROW() }
 
-BOOST_FIXTURE_TEST_CASE(deferred_transaction_tests, validating_tester) { try {
+BOOST_FIXTURE_TEST_CASE(deferred_transaction_tests, validating_tester_no_disable_deferrd_trx) { try {
    produce_blocks(2);
    create_accounts( {"testapi"_n, "testapi2"_n, "alice"_n} );
    set_code( "testapi"_n, test_contracts::test_api_wasm() );

unittests/currency_tests.cpp

@@ -18,7 +18,7 @@ using namespace eosio::chain;
 using namespace eosio::testing;
 using namespace fc;
 
-class currency_tester : public validating_tester {
+class currency_tester : public validating_tester_no_disable_deferrd_trx {
    public:
 
       auto push_action(const account_name& signer, const action_name &name, const variant_object &data ) {
@@ -64,7 +64,7 @@ class currency_tester : public validating_tester {
       }
 
       currency_tester()
-         :validating_tester(),abi_ser(json::from_string(test_contracts::eosio_token_abi()).as<abi_def>(), abi_serializer::create_yield_function( abi_serializer_max_time ))
+         :validating_tester_no_disable_deferrd_trx(), abi_ser(json::from_string(test_contracts::eosio_token_abi()).as<abi_def>(), abi_serializer::create_yield_function( abi_serializer_max_time ))
       {
          create_account( "eosio.token"_n);
          set_code( "eosio.token"_n, test_contracts::eosio_token_wasm() );

unittests/deep_mind_tests.cpp

@@ -49,7 +49,7 @@ struct deep_mind_log_fixture
 
 struct deep_mind_tester : deep_mind_log_fixture, validating_tester
 {
-   deep_mind_tester() : validating_tester({}, &deep_mind_logger) {}
+   deep_mind_tester() : validating_tester({}, &deep_mind_logger, setup_policy::full_but_disable_deferrd_trx) {}
 };
 
 namespace {