Remove defer transaction configuration options and block incoming delayed transactions

docs/01_nodeos/03_plugins/producer_plugin/index.md

@@ -95,13 +95,6 @@ Config Options for eosio::producer_plugin:
                                         consider block full; when within
                                         threshold of max-block-net-usage block
                                         can be produced immediately
-  --max-scheduled-transaction-time-per-block-ms arg (=100)
-                                        Maximum wall-clock time, in
-                                        milliseconds, spent retiring scheduled
-                                        transactions (and incoming transactions
-                                        according to incoming-defer-ratio) in
-                                        any block before returning to normal
-                                        transaction processing.
   --subjective-cpu-leeway-us arg (=31000)
                                         Time in microseconds allowed for a
                                         transaction that starts with
@@ -114,9 +107,6 @@ Config Options for eosio::producer_plugin:
   --subjective-account-decay-time-minutes arg (=1440)
                                         Sets the time to return full subjective
                                         cpu for accounts
-  --incoming-defer-ratio arg (=1)       ratio between incoming transactions and
-                                        deferred transactions when both are
-                                        queued for execution
   --incoming-transaction-queue-size-mb arg (=1024)
                                         Maximum size (in MiB) of the incoming
                                         transaction queue. Exceeding this value
@@ -142,21 +132,6 @@ Config Options for eosio::producer_plugin:
 
 * [`chain_plugin`](../chain_plugin/index.md)
 
-## The priority of transaction
-
-You can give one of the transaction types priority over another when the producer plugin has a queue of transactions pending.
-
-The option below sets the ratio between the incoming transaction and the deferred transaction:
-
-```console
-  --incoming-defer-ratio arg (=1)       
-```
-
-By default value of `1`, the `producer` plugin processes one incoming transaction per deferred transaction. When `arg` sets to `10`, the `producer` plugin processes 10 incoming transactions per deferred transaction.
-
-If the `arg` is set to a sufficiently large number, the plugin always processes the incoming transaction first until the queue of the incoming transactions is empty. Respectively, if the `arg` is 0, the `producer` plugin processes the deferred transactions queue first.
-
-
 ### Load Dependency Examples
 
 ```console

libraries/chain/controller.cpp

@@ -1583,14 +1583,12 @@ struct controller_impl {
                                                trx->packed_trx()->get_prunable_size() );
             }
 
-            trx_context.delay = fc::seconds(trn.delay_sec);
-
             if( check_auth ) {
                authorization.check_authorization(
                        trn.actions,
                        trx->recovered_keys(),
                        {},
-                       trx_context.delay,
+                       fc::seconds(trn.delay_sec),
                        [&trx_context](){ trx_context.checktime(); },
                        false,
                        trx->is_dry_run()
@@ -1603,9 +1601,7 @@ struct controller_impl {
 
             trx->billed_cpu_time_us = trx_context.billed_cpu_time_us;
             if (!trx->implicit() && !trx->is_read_only()) {
-               transaction_receipt::status_enum s = (trx_context.delay == fc::seconds(0))
-                                                    ? transaction_receipt::executed
-                                                    : transaction_receipt::delayed;
+               transaction_receipt::status_enum s = transaction_receipt::executed;
                trace->receipt = push_receipt(*trx->packed_trx(), s, trx_context.billed_cpu_time_us, trace->net_usage);
                std::get<building_block>(pending->_block_stage)._pending_trx_metas.emplace_back(trx);
             } else {

libraries/chain/include/eosio/chain/transaction_context.hpp

@@ -112,7 +112,6 @@ namespace eosio { namespace chain {
 
          void execute_action( uint32_t action_ordinal, uint32_t recurse_depth );
 
-         void schedule_transaction();
          void record_transaction( const transaction_id_type& id, fc::time_point_sec expire );
 
          void validate_cpu_usage_to_bill( int64_t billed_us, int64_t account_cpu_limit, bool check_minimum, int64_t subjective_billed_us )const;
@@ -143,7 +142,6 @@ namespace eosio { namespace chain {
          /// the maximum number of virtual CPU instructions of the transaction that can be safely billed to the billable accounts
          uint64_t                      initial_max_billable_cpu = 0;
 
-         fc::microseconds              delay;
          bool                          is_input           = false;
          bool                          apply_context_free = true;
          bool                          enforce_whiteblacklist = true;

libraries/chain/transaction_context.cpp

@@ -247,9 +247,7 @@ namespace eosio { namespace chain {
                                                  uint64_t packed_trx_prunable_size )
    {
       const transaction& trx = packed_trx.get_transaction();
-      if ( is_transient() ) {
-         EOS_ASSERT( trx.delay_sec.value == 0, transaction_exception, "dry-run or read-only transaction cannot be delayed" );
-      }
+      EOS_ASSERT( trx.delay_sec.value == 0, transaction_exception, "transaction cannot be delayed" );
       if( trx.transaction_extensions.size() > 0 ) {
          disallow_transaction_extensions( "no transaction extensions supported yet for input transactions" );
       }
@@ -268,14 +266,6 @@ namespace eosio { namespace chain {
       uint64_t initial_net_usage = static_cast<uint64_t>(cfg.base_per_transaction_net_usage)
                                     + packed_trx_unprunable_size + discounted_size_for_pruned_data;
 
-
-      if( trx.delay_sec.value > 0 ) {
-          // If delayed, also charge ahead of time for the additional net usage needed to retire the delayed transaction
-          // whether that be by successfully executing, soft failure, hard failure, or expiration.
-         initial_net_usage += static_cast<uint64_t>(cfg.base_per_transaction_net_usage)
-                               + static_cast<uint64_t>(config::transaction_id_net_usage);
-      }
-
       published = control.pending_block_time();
       is_input = true;
       if (!control.skip_trx_checks()) {
@@ -319,21 +309,15 @@ namespace eosio { namespace chain {
          }
       }
 
-      if( delay == fc::microseconds() ) {
-         for( const auto& act : trx.actions ) {
-            schedule_action( act, act.account, false, 0, 0 );
-         }
+      for( const auto& act : trx.actions ) {
+         schedule_action( act, act.account, false, 0, 0 );
       }
 
       auto& action_traces = trace->action_traces;
       uint32_t num_original_actions_to_execute = action_traces.size();
       for( uint32_t i = 1; i <= num_original_actions_to_execute; ++i ) {
          execute_action( i, 0 );
       }
-
-      if( delay != fc::microseconds() ) {
-         schedule_transaction();
-      }
    }
 
    void transaction_context::finalize() {
@@ -731,43 +715,6 @@ namespace eosio { namespace chain {
       acontext.exec();
    }
 
-
-   void transaction_context::schedule_transaction() {
-      // Charge ahead of time for the additional net usage needed to retire the delayed transaction
-      // whether that be by successfully executing, soft failure, hard failure, or expiration.
-      const transaction& trx = packed_trx.get_transaction();
-      if( trx.delay_sec.value == 0 ) { // Do not double bill. Only charge if we have not already charged for the delay.
-         const auto& cfg = control.get_global_properties().configuration;
-         add_net_usage( static_cast<uint64_t>(cfg.base_per_transaction_net_usage)
-                         + static_cast<uint64_t>(config::transaction_id_net_usage) ); // Will exit early if net usage cannot be payed.
-      }
-
-      auto first_auth = trx.first_authorizer();
-
-      uint32_t trx_size = 0;
-      const auto& cgto = control.mutable_db().create<generated_transaction_object>( [&]( auto& gto ) {
-        gto.trx_id      = id;
-        gto.payer       = first_auth;
-        gto.sender      = account_name(); /// delayed transactions have no sender
-        gto.sender_id   = transaction_id_to_sender_id( gto.trx_id );
-        gto.published   = control.pending_block_time();
-        gto.delay_until = gto.published + delay;
-        gto.expiration  = gto.delay_until + fc::seconds(control.get_global_properties().configuration.deferred_trx_expiration_window);
-        trx_size = gto.set( trx );
-
-        if (auto dm_logger = control.get_deep_mind_logger(is_transient())) {
-           std::string event_id = RAM_EVENT_ID("${id}", ("id", gto.id));
-
-           dm_logger->on_create_deferred(deep_mind_handler::operation_qualifier::push, gto, packed_trx);
-           dm_logger->on_ram_trace(std::move(event_id), "deferred_trx", "push", "deferred_trx_pushed");
-        }
-      });
-
-      int64_t ram_delta = (config::billable_size_v<generated_transaction_object> + trx_size);
-      add_ram_usage( cgto.payer, ram_delta );
-      trace->account_ram_delta = account_delta( cgto.payer, ram_delta );
-   }
-
    void transaction_context::record_transaction( const transaction_id_type& id, fc::time_point_sec expire ) {
       try {
           control.mutable_db().create<transaction_object>([&](transaction_object& transaction) {

plugins/producer_plugin/include/eosio/producer_plugin/producer_plugin.hpp

@@ -18,9 +18,7 @@ class producer_plugin : public appbase::plugin<producer_plugin> {
       std::optional<int32_t>   max_transaction_time;
       std::optional<int32_t>   max_irreversible_block_age;
       std::optional<int32_t>   cpu_effort_us;
-      std::optional<int32_t>   max_scheduled_transaction_time_per_block_ms;
       std::optional<int32_t>   subjective_cpu_leeway_us;
-      std::optional<double>    incoming_defer_ratio;
       std::optional<uint32_t>  greylist_limit;
    };
 
@@ -162,7 +160,6 @@ class producer_plugin : public appbase::plugin<producer_plugin> {
 
    struct produced_block_metrics : public speculative_block_metrics {
       std::size_t unapplied_transactions_total       = 0;
-      std::size_t blacklisted_transactions_total     = 0;
       std::size_t subjective_bill_account_size_total = 0;
       std::size_t scheduled_trxs_total               = 0;
       std::size_t trxs_produced_total                = 0;
@@ -199,7 +196,7 @@ class producer_plugin : public appbase::plugin<producer_plugin> {
 
 } //eosio
 
-FC_REFLECT(eosio::producer_plugin::runtime_options, (max_transaction_time)(max_irreversible_block_age)(cpu_effort_us)(max_scheduled_transaction_time_per_block_ms)(subjective_cpu_leeway_us)(incoming_defer_ratio)(greylist_limit));
+FC_REFLECT(eosio::producer_plugin::runtime_options, (max_transaction_time)(max_irreversible_block_age)(cpu_effort_us)(subjective_cpu_leeway_us)(greylist_limit));
 FC_REFLECT(eosio::producer_plugin::greylist_params, (accounts));
 FC_REFLECT(eosio::producer_plugin::whitelist_blacklist, (actor_whitelist)(actor_blacklist)(contract_whitelist)(contract_blacklist)(action_blacklist)(key_blacklist) )
 FC_REFLECT(eosio::producer_plugin::integrity_hash_information, (head_block_id)(integrity_hash))