Add deprecate_deferred_transactions protocol feature

libraries/chain/apply_context.cpp

@@ -486,6 +486,13 @@ void apply_context::schedule_deferred_transaction( const uint128_t& sender_id, a
    }
 
    uint32_t trx_size = 0;
+
+   bool stop_deferred_transactions_activated = control.is_builtin_activated(builtin_protocol_feature_t::stop_deferred_transactions);
+
+   if ( stop_deferred_transactions_activated ) {
+       EOS_ASSERT( replace_existing, stop_deferred_tx, "you may only replace existing deferred transactions; not generate new ones" );
+   }
+
    if ( auto ptr = db.find<generated_transaction_object,by_sender_id>(boost::make_tuple(receiver, sender_id)) ) {
       EOS_ASSERT( replace_existing, deferred_tx_duplicate, "deferred transaction with the same sender_id and payer already exists" );
 
@@ -512,29 +519,33 @@ void apply_context::schedule_deferred_transaction( const uint128_t& sender_id, a
 
       // Use remove and create rather than modify because mutating the trx_id field in a modifier is unsafe.
       db.remove( *ptr );
-      db.create<generated_transaction_object>( [&]( auto& gtx ) {
-         gtx.trx_id      = trx_id_for_new_obj;
-         gtx.sender      = receiver;
-         gtx.sender_id   = sender_id;
-         gtx.payer       = payer;
-         gtx.published   = control.pending_block_time();
-         gtx.delay_until = gtx.published + delay;
-         gtx.expiration  = gtx.delay_until + fc::seconds(control.get_global_properties().configuration.deferred_trx_expiration_window);
-
-         trx_size = gtx.set( trx );
-      } );
+      if ( !stop_deferred_transactions_activated ) {
+         db.create<generated_transaction_object>( [&]( auto& gtx ) {
+            gtx.trx_id      = trx_id_for_new_obj;
+            gtx.sender      = receiver;
+            gtx.sender_id   = sender_id;
+            gtx.payer       = payer;
+            gtx.published   = control.pending_block_time();
+            gtx.delay_until = gtx.published + delay;
+            gtx.expiration  = gtx.delay_until + fc::seconds(control.get_global_properties().configuration.deferred_trx_expiration_window);
+
+            trx_size = gtx.set( trx );
+         } );
+      }
    } else {
-      db.create<generated_transaction_object>( [&]( auto& gtx ) {
-         gtx.trx_id      = trx.id();
-         gtx.sender      = receiver;
-         gtx.sender_id   = sender_id;
-         gtx.payer       = payer;
-         gtx.published   = control.pending_block_time();
-         gtx.delay_until = gtx.published + delay;
-         gtx.expiration  = gtx.delay_until + fc::seconds(control.get_global_properties().configuration.deferred_trx_expiration_window);
-
-         trx_size = gtx.set( trx );
-      } );
+      if ( !stop_deferred_transactions_activated ) {
+         db.create<generated_transaction_object>( [&]( auto& gtx ) {
+            gtx.trx_id      = trx.id();
+            gtx.sender      = receiver;
+            gtx.sender_id   = sender_id;
+            gtx.payer       = payer;
+            gtx.published   = control.pending_block_time();
+            gtx.delay_until = gtx.published + delay;
+            gtx.expiration  = gtx.delay_until + fc::seconds(control.get_global_properties().configuration.deferred_trx_expiration_window);
+
+            trx_size = gtx.set( trx );
+         } );
+      }
    }
 
    EOS_ASSERT( ram_restrictions_activated

libraries/chain/controller.cpp

@@ -1244,7 +1244,10 @@ struct controller_impl {
       trx->accepted = true;
 
       transaction_trace_ptr trace;
-      if( gtrx.expiration < self.pending_block_time() ) {
+
+      bool stop_deferred_transactions_activated = self.is_builtin_activated(builtin_protocol_feature_t::stop_deferred_transactions);
+
+      if( gtrx.expiration < self.pending_block_time() || stop_deferred_transactions_activated ) {
          trace = std::make_shared<transaction_trace>();
          trace->id = gtrx.trx_id;
          trace->block_num = self.head_block_num() + 1;
@@ -1467,6 +1470,11 @@ struct controller_impl {
 
             trx_context.delay = fc::seconds(trn.delay_sec);
 
+            if ( trx_context.delay.count() > 0 ) {
+               bool stop_deferred_transactions_activated = self.is_builtin_activated(builtin_protocol_feature_t::stop_deferred_transactions);
+               EOS_ASSERT( !stop_deferred_transactions_activated, stop_deferred_tx, "delay seconds must be 0" );
+            }
+
             if( check_auth ) {
                authorization.check_authorization(
                        trn.actions,

libraries/chain/include/eosio/chain/exceptions.hpp

@@ -279,6 +279,8 @@ namespace eosio { namespace chain {
                                     3040018, "Transaction exceeded transient resource limit" )
       FC_DECLARE_DERIVED_EXCEPTION( tx_prune_exception, transaction_exception,
                                     3040019, "Prunable data not found" )
+      FC_DECLARE_DERIVED_EXCEPTION( stop_deferred_tx, transaction_exception,
+                                    3040019, "Deferred transactions have been stopped" )
 
 
    FC_DECLARE_DERIVED_EXCEPTION( action_validate_exception, chain_exception,

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

@@ -24,6 +24,7 @@ enum class builtin_protocol_feature_t : uint32_t {
    webauthn_key,
    wtmsig_block_signatures,
    action_return_value,
+   stop_deferred_transactions
 };
 
 struct protocol_feature_subjective_restrictions {

libraries/chain/protocol_feature_manager.cpp

@@ -194,6 +194,18 @@ may use a new `set_proposed_producers_ex` intrinsic to access extended features.
 Builtin protocol feature: ACTION_RETURN_VALUE
 
 Enables new `set_action_return_value` intrinsic which sets a value that is included in action_receipt.
+*/
+            {}
+         } )
+
+         (  builtin_protocol_feature_t::stop_deferred_transactions, builtin_protocol_feature_spec{
+            "DEPRECATE_DEFERRED_TRANSACTIONS",
+            fc::variant("56e2c91142e6ca088a2e982c51f94fc944ea9e478e4113fc46649d5e2c04b5b1").as<digest_type>(),
+            // SHA256 hash of the raw message below within the comment delimiters (do not modify message below).
+/*
+Builtin protocol feature: DEPRECATE_DEFERRED_TRANSACTIONS
+
+Stops the ability to perform a deferred transaction.
 */
             {}
          } )

libraries/chain/wasm_interface.cpp

@@ -1491,6 +1491,12 @@ class transaction_api : public context_aware_api {
       }
 
       void send_deferred( const uint128_t& sender_id, account_name payer, array_ptr<char> data, uint32_t data_len, uint32_t replace_existing) {
+         bool stop_deferred_transactions_activated = context.control.is_builtin_activated(builtin_protocol_feature_t::stop_deferred_transactions);
+
+         if ( stop_deferred_transactions_activated && replace_existing ) {
+            return;
+         }
+
          transaction trx;
          fc::raw::unpack<transaction>(data, data_len, trx);
          context.schedule_deferred_transaction(sender_id, payer, std::move(trx), replace_existing);

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

@@ -62,7 +62,7 @@ namespace eosio { namespace testing {
       old_bios_only,
       preactivate_feature_only,
       preactivate_feature_and_new_bios,
-      full
+      complete
    };
 
    std::vector<uint8_t> read_wasm( const char* fn );
@@ -146,13 +146,12 @@ namespace eosio { namespace testing {
          typedef string action_result;
 
          static const uint32_t DEFAULT_EXPIRATION_DELTA = 6;
-
          static const uint32_t DEFAULT_BILLED_CPU_TIME_US = 2000;
          static const fc::microseconds abi_serializer_max_time;
 
          virtual ~base_tester() {};
 
-         void              init(const setup_policy policy = setup_policy::full, db_read_mode read_mode = db_read_mode::SPECULATIVE);
+         void              init(const setup_policy policy = setup_policy::complete, db_read_mode read_mode = db_read_mode::SPECULATIVE);
          void              init(controller::config config, const snapshot_reader_ptr& snapshot);
          void              init(controller::config config, const genesis_state& genesis);
          void              init(controller::config config);
@@ -379,7 +378,7 @@ namespace eosio { namespace testing {
 
          void schedule_protocol_features_wo_preactivation(const vector<digest_type> feature_digests);
          void preactivate_protocol_features(const vector<digest_type> feature_digests);
-         void preactivate_all_builtin_protocol_features();
+         void preactivate_builtin_protocol_features(const std::vector<builtin_protocol_feature_t>& ignored_features);
 
          static genesis_state default_genesis() {
             genesis_state genesis;
@@ -432,15 +431,16 @@ namespace eosio { namespace testing {
          controller::config                            cfg;
          map<transaction_id_type, transaction_receipt> chain_transactions;
          map<account_name, block_id_type>              last_produced_block;
-         unapplied_transaction_queue                   unapplied_transactions;
+         unapplied_transaction_queue                   unapplied_transactions;         
 
       public:
+         vector<builtin_protocol_feature_t>            ignored_features;
          vector<digest_type>                           protocol_features_to_be_activated_wo_preactivation;
    };
 
    class tester : public base_tester {
    public:
-      tester(setup_policy policy = setup_policy::full, db_read_mode read_mode = db_read_mode::SPECULATIVE) {
+      tester(setup_policy policy = setup_policy::complete, db_read_mode read_mode = db_read_mode::SPECULATIVE) {
          init(policy, read_mode);
       }
 
@@ -516,49 +516,30 @@ namespace eosio { namespace testing {
             wdump((e.to_detail_string()));
          }
       }
-      controller::config vcfg;
-
-      validating_tester(const flat_set<account_name>& trusted_producers = flat_set<account_name>()) {
-         auto def_conf = default_config(tempdir);
 
+      validating_tester(const ::boost::container::flat_set<::eosio::chain::account_name>& trusted_producers = ::boost::container::flat_set<::eosio::chain::account_name>(),
+                        const ::std::vector<::eosio::chain::builtin_protocol_feature_t>& ignored_features = {},
+                        const ::eosio::testing::setup_policy& policy = ::eosio::testing::setup_policy::complete) {
+         ::std::pair<::eosio::chain::controller::config, ::eosio::chain::genesis_state> def_conf = default_config(tempdir); 
+         ::eosio::testing::base_tester::ignored_features = ignored_features;
          vcfg = def_conf.first;
          config_validator(vcfg);
          vcfg.trusted_producers = trusted_producers;
-
          validating_node = create_validating_node(vcfg, def_conf.second, true);
-
          init(def_conf.first, def_conf.second);
-         execute_setup_policy(setup_policy::full);
-      }
-
-      static void config_validator(controller::config& vcfg) {
-         FC_ASSERT( vcfg.blocks_dir.filename().generic_string() != "."
-                    && vcfg.state_dir.filename().generic_string() != ".", "invalid path names in controller::config" );
-
-         vcfg.blocks_dir = vcfg.blocks_dir.parent_path() / std::string("v_").append( vcfg.blocks_dir.filename().generic_string() );
-         vcfg.state_dir  = vcfg.state_dir.parent_path() / std::string("v_").append( vcfg.state_dir.filename().generic_string() );
-
-         vcfg.contracts_console = false;
-      }
-
-      static unique_ptr<controller> create_validating_node(controller::config vcfg, const genesis_state& genesis, bool use_genesis) {
-         unique_ptr<controller> validating_node = std::make_unique<controller>(vcfg, make_protocol_feature_set(), genesis.compute_chain_id());
-         validating_node->add_indices();
-         if (use_genesis) {
-            validating_node->startup( [](){}, []() { return false; }, genesis );
-         }
-         else {
-            validating_node->startup( [](){}, []() { return false; } );
-         }
-         return validating_node;
+         execute_setup_policy(policy);
       }
 
-      validating_tester(const fc::temp_directory& tempdir, bool use_genesis) {
+      // Delete this one after I fix the default one
+      validating_tester(const fc::temp_directory& tempdir, bool use_genesis, const std::vector<builtin_protocol_feature_t>& ignored_features = {}) {
+         base_tester::ignored_features = ignored_features;
+
          auto def_conf = default_config(tempdir);
          vcfg = def_conf.first;
          config_validator(vcfg);
+
          validating_node = create_validating_node(vcfg, def_conf.second, use_genesis);
-
+      
          if (use_genesis) {
             init(def_conf.first, def_conf.second);
          }
@@ -573,6 +554,7 @@ namespace eosio { namespace testing {
          conf_edit(def_conf.first);
          vcfg = def_conf.first;
          config_validator(vcfg);
+
          validating_node = create_validating_node(vcfg, def_conf.second, use_genesis);
 
          if (use_genesis) {
@@ -583,6 +565,28 @@ namespace eosio { namespace testing {
          }
       }
 
+      static void config_validator(controller::config& vcfg) {
+         FC_ASSERT( vcfg.blocks_dir.filename().generic_string() != "."
+                    && vcfg.state_dir.filename().generic_string() != ".", "invalid path names in controller::config" );
+
+         vcfg.blocks_dir = vcfg.blocks_dir.parent_path() / std::string("v_").append( vcfg.blocks_dir.filename().generic_string() );
+         vcfg.state_dir  = vcfg.state_dir.parent_path() / std::string("v_").append( vcfg.state_dir.filename().generic_string() );
+
+         vcfg.contracts_console = false;
+      }
+
+      static unique_ptr<controller> create_validating_node(controller::config vcfg, const genesis_state& genesis, bool use_genesis) {
+         unique_ptr<controller> validating_node = std::make_unique<controller>(vcfg, make_protocol_feature_set(), genesis.compute_chain_id());
+         validating_node->add_indices();
+         if (use_genesis) {
+            validating_node->startup( [](){}, []() { return false; }, genesis );
+         }
+         else {
+            validating_node->startup( [](){}, []() { return false; } );
+         }
+         return validating_node;
+      }
+
       signed_block_ptr produce_block( fc::microseconds skip_time = fc::milliseconds(config::block_interval_ms) )override {
          auto sb = _produce_block(skip_time, false);
          auto bsf = validating_node->create_block_state_future( sb );
@@ -614,8 +618,6 @@ namespace eosio { namespace testing {
       }
 
       bool validate() {
-
-
         auto hbh = control->head_block_state()->header;
         auto vn_hbh = validating_node->head_block_state()->header;
         bool ok = control->head_block_id() == validating_node->head_block_id() &&
@@ -633,9 +635,10 @@ namespace eosio { namespace testing {
         return ok;
       }
 
-      unique_ptr<controller>   validating_node;
-      uint32_t                 num_blocks_to_producer_before_shutdown = 0;
-      bool                     skip_validate = false;
+      controller::config          vcfg;
+      std::unique_ptr<controller> validating_node;
+      uint32_t                    num_blocks_to_producer_before_shutdown = 0;
+      bool                        skip_validate = false;
    };
 
    /**

libraries/testing/tester.cpp

@@ -214,11 +214,11 @@ namespace eosio { namespace testing {
             set_before_producer_authority_bios_contract();
             break;
          }
-         case setup_policy::full: {
+         case setup_policy::complete: {
             schedule_preactivate_protocol_feature();
             produce_block();
             set_before_producer_authority_bios_contract();
-            preactivate_all_builtin_protocol_features();
+            preactivate_builtin_protocol_features(ignored_features);
             produce_block();
             set_bios_contract();
             break;
@@ -1116,24 +1116,47 @@ namespace eosio { namespace testing {
       }
    }
 
-   void base_tester::preactivate_all_builtin_protocol_features() {
+   void base_tester::preactivate_builtin_protocol_features(const std::vector<builtin_protocol_feature_t>& ignored_features) {
       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);
       const auto current_block_time = ( control->is_building_block() ? control->pending_block_time()
                                         : control->head_block_time() + fc::milliseconds(config::block_interval_ms) );
 
-      set<digest_type>    preactivation_set;
-      vector<digest_type> preactivations;
+      set<digest_type>         preactivation_set;
+      vector<digest_type>      preactivations;
+      std::vector<digest_type> ignored_digests;
+
+      ignored_digests.reserve(ignored_features.size());
+      for ( const auto& feature : ignored_features ) {
+         ignored_digests.push_back(*pfs.get_builtin_digest( feature ) );
+      }
 
       std::function<void(const digest_type&)> add_digests =
-      [&pfm, &pfs, current_block_num, current_block_time, &preactivation_set, &preactivations, &add_digests]
+      [&ignored_digests, &pfm, &pfs, current_block_num, current_block_time, &preactivation_set, &preactivations, &add_digests]
       ( const digest_type& feature_digest ) {
          const auto& pf = pfs.get_protocol_feature( feature_digest );
          FC_ASSERT( pf.builtin_feature, "called add_digests on a non-builtin protocol feature" );
          if( !pf.enabled || pf.earliest_allowed_activation_time > current_block_time
              || pfm.is_builtin_activated( *pf.builtin_feature, current_block_num ) ) return;
 
+         std::function<void(const digest_type&)> check_dependencies =
+         [&check_dependencies, &ignored_digests, &pf] ( const digest_type& feature ) {
+            const auto dependency_is_ignored     = std::find( ignored_digests.cbegin(), ignored_digests.cend(), feature );
+            const auto dependency_has_dependency = std::find( pf.dependencies.cbegin(),  pf.dependencies.cend(),  feature );
+            if ( dependency_is_ignored != ignored_digests.cend() && dependency_has_dependency != pf.dependencies.cend() ) {
+                check_dependencies(*dependency_has_dependency);
+            } else {
+                FC_ASSERT( pf.builtin_feature, "ignoring a protocol feature that is a dependency for another protocol feature" );
+            }
+         };
+
+         const auto digest_is_ignored = std::find(ignored_digests.cbegin(), ignored_digests.cend(), feature_digest);
+         if( digest_is_ignored != ignored_digests.cend() ) {
+            check_dependencies(*digest_is_ignored);
+            return;
+         }
+
          auto res = preactivation_set.emplace( feature_digest );
          if( !res.second ) return;