cleanup(congestion) - removed local congestion control

Author: wacban

Diff for: chain/chain/src/runtime/mod.rs

@@ -11,7 +11,7 @@ use near_chain_configs::{GenesisConfig, MIN_GC_NUM_EPOCHS_TO_KEEP, ProtocolConfi
 use near_crypto::PublicKey;
 use near_epoch_manager::shard_assignment::account_id_to_shard_id;
 use near_epoch_manager::{EpochManagerAdapter, EpochManagerHandle};
-use near_parameters::{ActionCosts, ExtCosts, RuntimeConfig, RuntimeConfigStore};
+use near_parameters::{ExtCosts, RuntimeConfig, RuntimeConfigStore};
 use near_pool::types::TransactionGroupIterator;
 use near_primitives::account::{AccessKey, Account};
 use near_primitives::apply::ApplyChunkReason;
@@ -20,13 +20,12 @@ use near_primitives::congestion_info::{
 };
 use near_primitives::errors::{InvalidTxError, RuntimeError, StorageError};
 use near_primitives::hash::{CryptoHash, hash};
-use near_primitives::receipt::{DelayedReceiptIndices, Receipt};
+use near_primitives::receipt::Receipt;
 use near_primitives::runtime::migration_data::{MigrationData, MigrationFlags};
 use near_primitives::sandbox::state_patch::SandboxStatePatch;
 use near_primitives::shard_layout::{ShardLayout, ShardUId};
 use near_primitives::state_part::PartId;
 use near_primitives::transaction::{SignedTransaction, ValidatedTransaction};
-use near_primitives::trie_key::TrieKey;
 use near_primitives::types::{
     AccountId, Balance, BlockHeight, EpochHeight, EpochId, EpochInfoProvider, Gas, MerkleHash,
     ShardId, StateChangeCause, StateRoot, StateRootNode,
@@ -662,18 +661,6 @@ impl RuntimeAdapter for NightshadeRuntime {
         };
         let mut num_checked_transactions = 0;
 
-        // To avoid limiting the throughput of the network, we want to include enough receipts to
-        // saturate the capacity of the chunk even in case when all of these receipts end up using
-        // the smallest possible amount of gas, which is at least the cost of execution of action
-        // receipt.
-        // Currently, the min execution cost is ~100 GGas and the chunk capacity is 1 PGas, giving
-        // a bound of at most 10000 receipts processed in a chunk.
-        let delayed_receipts_indices: DelayedReceiptIndices =
-            near_store::get(&state_update, &TrieKey::DelayedReceiptIndices)?.unwrap_or_default();
-        let min_fee = runtime_config.fees.fee(ActionCosts::new_action_receipt).exec_fee();
-        let new_receipt_count_limit =
-            get_new_receipt_count_limit(min_fee, gas_limit, delayed_receipts_indices);
-
         let size_limit: u64 = calculate_transactions_size_limit(
             protocol_version,
             &runtime_config,
@@ -695,17 +682,6 @@ impl RuntimeAdapter for NightshadeRuntime {
                 result.limited_by = Some(PrepareTransactionsLimit::Size);
                 break;
             }
-            if !ProtocolFeature::CongestionControl.enabled(protocol_version) {
-                // Local Congestion Control.
-                // Keep this for the upgrade phase, afterwards it can be
-                // removed. It does not need to be kept because it does not
-                // affect replayability.
-                // TODO(congestion_control): remove at release CongestionControl + 1 or later
-                if result.transactions.len() >= new_receipt_count_limit {
-                    result.limited_by = Some(PrepareTransactionsLimit::ReceiptCount);
-                    break;
-                }
-            }
 
             if let Some(time_limit) = &time_limit {
                 if start_time.elapsed() >= *time_limit {
@@ -1285,27 +1261,6 @@ impl RuntimeAdapter for NightshadeRuntime {
     }
 }
 
-/// Get the limit on the number of new receipts imposed by the local congestion control.
-fn get_new_receipt_count_limit(
-    min_fee: u64,
-    gas_limit: u64,
-    delayed_receipts_indices: DelayedReceiptIndices,
-) -> usize {
-    if min_fee == 0 {
-        return usize::MAX;
-    }
-    // Round up to include at least one receipt.
-    let max_processed_receipts_in_chunk = (gas_limit + min_fee - 1) / min_fee;
-    // Allow at most 2 chunks worth of delayed receipts. This way under congestion,
-    // after processing a single chunk, we will still have at least 1 chunk worth of
-    // delayed receipts, ensuring the high throughput even if the next chunk producer
-    // does not include any receipts.
-    // This buffer size is a trade-off between the max queue size and system efficiency
-    // under congestion.
-    let delayed_receipt_count_limit = max_processed_receipts_in_chunk * 2;
-    delayed_receipt_count_limit.saturating_sub(delayed_receipts_indices.len()) as usize
-}
-
 /// How much gas of the next chunk we want to spend on converting new
 /// transactions to receipts.
 fn chunk_tx_gas_limit(