Move burn() back into FeeCalculator

Appease BPF tests

Author: t-nelson

runtime/src/bank.rs

@@ -751,7 +751,7 @@ impl Bank {
         let collector_fees = self.collector_fees.load(Ordering::Relaxed) as u64;
 
         if collector_fees != 0 {
-            let (unburned, burned) = self.fee_rate_governor.burn(collector_fees);
+            let (unburned, burned) = self.fee_calculator.burn(collector_fees);
             // burn a portion of fees
             self.deposit(&self.collector_id, unburned);
             self.capitalization.fetch_sub(burned, Ordering::Relaxed);
@@ -3453,9 +3453,9 @@ mod tests {
         } = create_genesis_config_with_leader(mint, &leader, 3);
         genesis_config.fee_rate_governor.lamports_per_signature = 4; // something divisible by 2
 
-        let expected_fee_paid = genesis_config.fee_rate_governor.lamports_per_signature;
-        let (expected_fee_collected, expected_fee_burned) =
-            genesis_config.fee_rate_governor.burn(expected_fee_paid);
+        let fee_calculator = genesis_config.fee_rate_governor.create_fee_calculator();
+        let expected_fee_paid = fee_calculator.lamports_per_signature;
+        let (expected_fee_collected, expected_fee_burned) = fee_calculator.burn(expected_fee_paid);
 
         let mut bank = Bank::new(&genesis_config);
 
@@ -3601,7 +3601,7 @@ mod tests {
             bank.get_balance(&leader),
             initial_balance
                 + bank
-                    .fee_rate_governor
+                    .fee_calculator
                     .burn(bank.fee_calculator.lamports_per_signature * 2)
                     .0
         );

sdk/src/fee_calculator.rs

@@ -8,12 +8,16 @@ pub struct FeeCalculator {
     // The current cost of a signature  This amount may increase/decrease over time based on
     // cluster processing load.
     pub lamports_per_signature: u64,
+
+    // What portion of collected fees are to be destroyed, as a fraction of std::u8::MAX
+    pub burn_percent: u8,
 }
 
 impl Default for FeeCalculator {
     fn default() -> Self {
         Self {
             lamports_per_signature: 0,
+            burn_percent: DEFAULT_BURN_PERCENT,
         }
     }
 }
@@ -22,12 +26,19 @@ impl FeeCalculator {
     pub fn new(lamports_per_signature: u64) -> Self {
         Self {
             lamports_per_signature,
+            ..FeeCalculator::default()
         }
     }
 
     pub fn calculate_fee(&self, message: &Message) -> u64 {
         self.lamports_per_signature * u64::from(message.header.num_required_signatures)
     }
+
+    /// calculate unburned fee from a fee total, returns (unburned, burned)
+    pub fn burn(&self, fees: u64) -> (u64, u64) {
+        let burned = fees * u64::from(self.burn_percent) / 100;
+        (fees - burned, burned)
+    }
 }
 
 #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
@@ -148,16 +159,11 @@ impl FeeRateGovernor {
         me
     }
 
-    /// calculate unburned fee from a fee total, returns (unburned, burned)
-    pub fn burn(&self, fees: u64) -> (u64, u64) {
-        let burned = fees * u64::from(self.burn_percent) / 100;
-        (fees - burned, burned)
-    }
-
     /// create a FeeCalculator based on current cluster signature throughput
     pub fn create_fee_calculator(&self) -> FeeCalculator {
         FeeCalculator {
             lamports_per_signature: self.lamports_per_signature,
+            burn_percent: self.burn_percent,
         }
     }
 }
@@ -168,15 +174,15 @@ mod tests {
     use crate::{pubkey::Pubkey, system_instruction};
 
     #[test]
-    fn test_fee_rate_governor_burn() {
-        let mut fee_rate_governor = FeeRateGovernor::default();
-        assert_eq!(fee_rate_governor.burn(2), (1, 1));
+    fn test_fee_calculator_burn() {
+        let mut fee_calculator = FeeCalculator::default();
+        assert_eq!(fee_calculator.burn(2), (1, 1));
 
-        fee_rate_governor.burn_percent = 0;
-        assert_eq!(fee_rate_governor.burn(2), (2, 0));
+        fee_calculator.burn_percent = 0;
+        assert_eq!(fee_calculator.burn(2), (2, 0));
 
-        fee_rate_governor.burn_percent = 100;
-        assert_eq!(fee_rate_governor.burn(2), (0, 2));
+        fee_calculator.burn_percent = 100;
+        assert_eq!(fee_calculator.burn(2), (0, 2));
     }
 
     #[test]