feat(iota-core): calculate suggested gas price in the new sequencer for gas price feedback mechanism

crates/iota-core/src/authority.rs

@@ -209,6 +209,7 @@ pub mod authority_store_types;
 pub mod epoch_start_configuration;
 pub mod shared_object_congestion_tracker;
 pub mod shared_object_version_manager;
+pub mod suggested_gas_price_calculator;
 #[cfg(any(test, feature = "test-utils"))]
 pub mod test_authority_builder;
 pub mod transaction_deferral;

crates/iota-core/src/authority/authority_per_epoch_store.rs

@@ -94,6 +94,7 @@ use crate::{
         shared_object_version_manager::{
             AssignedTxAndVersions, ConsensusSharedObjVerAssignment, SharedObjVerManager,
         },
+        suggested_gas_price_calculator::SuggestedGasPriceCalculator,
     },
     checkpoints::{
         BuilderCheckpointSummary, CheckpointHeight, CheckpointServiceNotify, EpochStats,
@@ -157,7 +158,7 @@ type JwkAggregator = GenericMultiStakeAggregator<(JwkId, JWK), true>;
 /// Represents a scheduling result: a transaction can be either scheduled
 /// for execution, or deferred for some reason. Scheduling result is
 /// returned by the `try_schedule` method of `AuthorityPerEpochStore`.
-enum SchedulingResult {
+pub(crate) enum SchedulingResult {
     /// Scheduling result indicating that a transaction is scheduled to be
     /// executed at start time
     Schedule(/* start_time */ ExecutionTime),
@@ -3120,6 +3121,23 @@ impl AuthorityPerEpochStore {
             }
         );
 
+        let mut suggested_gas_price_calculator = SuggestedGasPriceCalculator::new(
+            self.get_max_execution_duration_per_commit(),
+            self.reference_gas_price(),
+            self.protocol_config().max_gas_price(),
+        );
+
+        fail_point_arg!(
+            "initial_suggested_gas_price_calculator",
+            |calculator: SuggestedGasPriceCalculator| {
+                info!(
+                    "Initialize suggested_gas_price_calculator to  {:?}",
+                    calculator
+                );
+                suggested_gas_price_calculator = calculator;
+            }
+        );
+
         let mut randomness_state_updated = false;
         for tx in transactions {
             let key = tx.0.transaction.key();
@@ -3141,6 +3159,7 @@ impl AuthorityPerEpochStore {
                     dkg_failed,
                     randomness_round.is_some(),
                     congestion_tracker,
+                    &mut suggested_gas_price_calculator,
                     authority_metrics,
                 )
                 .await?
@@ -3397,6 +3416,7 @@ impl AuthorityPerEpochStore {
         dkg_failed: bool,
         generating_randomness: bool,
         shared_object_congestion_tracker: &mut SharedObjectCongestionTracker,
+        suggested_gas_price_calculator: &mut SuggestedGasPriceCalculator,
         authority_metrics: &Arc<AuthorityMetrics>,
     ) -> IotaResult<ConsensusCertificateResult> {
         let _scope = monitored_scope("HandleConsensusTransaction");
@@ -3433,7 +3453,8 @@ impl AuthorityPerEpochStore {
                     // certificate here it means authority is byzantine and sent certificate after
                     // EndOfPublish (or we have some bug in ConsensusAdapter)
                     warn!(
-                        "[Byzantine authority] Authority {:?} sent a new, previously unseen certificate {:?} after it sent EndOfPublish message to consensus",
+                        "[Byzantine authority] Authority {:?} sent a new, previously unseen 
+                            certificate {:?} after it sent EndOfPublish message to consensus",
                         certificate_author.concise(),
                         certificate.digest()
                     );
@@ -3470,6 +3491,8 @@ impl AuthorityPerEpochStore {
                     previously_deferred_tx_digests,
                     shared_object_congestion_tracker,
                 );
+                let estimated_execution_duration =
+                    shared_object_congestion_tracker.get_estimated_execution_duration(&certificate);
 
                 match scheduling_result {
                     SchedulingResult::Defer(deferral_key, deferral_reason) => {
@@ -3496,24 +3519,21 @@ impl AuthorityPerEpochStore {
                                     ConsensusCertificateResult::Deferred(deferral_key)
                                 } else {
                                     // Cancel the transaction that has been deferred for too long.
-
-                                    let suggested_gas_price = shared_object_congestion_tracker
-                                        .compute_suggested_gas_price(&certificate)
-                                        .expect(
-                                            "cancelled transaction must have at least one shared \
-                                            object and calculated suggested gas price",
-                                        );
-
                                     debug!(
-                                        "Cancelling consensus certificate for transaction {:?} with \
-                                        deferral key {deferral_key:?} due to congestion on \
-                                        objects {congested_objects:?}: actual gas price: \
-                                        {}, suggested gas price: \
-                                        {suggested_gas_price}",
+                                        "Cancelling consensus certificate for transaction {:?} \
+                                            with deferral key {deferral_key:?} due to congestion \
+                                            on objects {congested_objects:?}",
                                         certificate.digest(),
-                                        certificate.transaction_data().gas_price(),
                                     );
 
+                                    // Calculate suggested gas price for the cancelled
+                                    // certificate.
+                                    let suggested_gas_price = suggested_gas_price_calculator
+                                        .calculate_suggested_gas_price(
+                                            &certificate,
+                                            estimated_execution_duration,
+                                        );
+
                                     ConsensusCertificateResult::Cancelled((
                                         certificate,
                                         CancelConsensusCertificateReason::CongestionOnObjects {
@@ -3524,24 +3544,35 @@ impl AuthorityPerEpochStore {
                                 }
                             }
                         };
-                        return Ok(deferral_result);
+
+                        Ok(deferral_result)
                     }
                     SchedulingResult::Schedule(start_time) => {
                         if dkg_failed && certificate.transaction_data().uses_randomness() {
                             debug!(
                                 "Canceling randomness-using certificate for transaction {:?} because DKG failed",
                                 certificate.digest(),
                             );
+
                             return Ok(ConsensusCertificateResult::Cancelled((
                                 certificate,
                                 CancelConsensusCertificateReason::DkgFailed,
                             )));
                         }
 
-                        // This certificate will be scheduled. Update object execution slots.
+                        // This certificate will be scheduled. If it contains shared object(s),
+                        // we have to update the following:
+                        // - shared object execution slots (for congestion tracker);
+                        // - shared object congestion info (for suggested gas price calculator).
                         if certificate.contains_shared_object() {
                             shared_object_congestion_tracker
                                 .bump_object_execution_slots(&certificate, start_time);
+
+                            suggested_gas_price_calculator.update_congestion_info(
+                                &certificate,
+                                start_time,
+                                estimated_execution_duration,
+                            );
                         }
 
                         Ok(ConsensusCertificateResult::Scheduled {