ServiceProvider -> SP for brevity

helium · Jul 16, 2024 · 861bd8f · 861bd8f
1 parent c3e8194
commit 861bd8f
Show file tree

Hide file tree

Showing 5 changed files with 50 additions and 61 deletions.
diff --git a/coverage_point_calculator/src/lib.rs b/coverage_point_calculator/src/lib.rs
@@ -64,7 +64,7 @@
 pub use crate::{
     hexes::{CoveredHex, HexPoints},
     location::{asserted_distance_to_trust_multiplier, LocationTrust},
-    service_provider_boosting::ServiceProviderBoostedRewardEligibility,
+    service_provider_boosting::SPBoostedRewardEligibility,
     speedtest::{BytesPs, Speedtest, SpeedtestTier},
 };
 use coverage_map::SignalLevel;
@@ -132,7 +132,7 @@ pub struct CoveragePoints {
     /// Input Radio Type
     pub radio_type: RadioType,
     /// Input ServiceProviderBoostedRewardEligibility
-    pub service_provider_boosted_reward_eligibility: ServiceProviderBoostedRewardEligibility,
+    pub service_provider_boosted_reward_eligibility: SPBoostedRewardEligibility,
     /// Derived Eligibility for Boosted Hex Rewards
     pub boosted_hex_eligibility: BoostedHexStatus,
     /// Speedtests used in calculcation
@@ -146,7 +146,7 @@ pub struct CoveragePoints {
 impl CoveragePoints {
     pub fn new(
         radio_type: RadioType,
-        service_provider_boosted_reward_eligibility: ServiceProviderBoostedRewardEligibility,
+        service_provider_boosted_reward_eligibility: SPBoostedRewardEligibility,
         speedtests: Vec<Speedtest>,
         location_trust_scores: Vec<LocationTrust>,
         ranked_coverage: Vec<coverage_map::RankedCoverage>,
@@ -240,18 +240,14 @@ impl BoostedHexStatus {
         radio_type: RadioType,
         location_trust_multiplier: Decimal,
         location_trust_scores: &[LocationTrust],
-        service_provider_boosted_reward_eligibility: ServiceProviderBoostedRewardEligibility,
+        service_provider_boosted_reward_eligibility: SPBoostedRewardEligibility,
     ) -> Self {
         match service_provider_boosted_reward_eligibility {
             // hip-125: if radio has been banned by service provider, no boosting
-            ServiceProviderBoostedRewardEligibility::ServiceProviderBanned => {
-                Self::ServiceProviderBanned
-            }
+            SPBoostedRewardEligibility::ServiceProviderBanned => Self::ServiceProviderBanned,
             // hip-84: if radio has not met minimum data and subscriber thresholds, no boosting
-            ServiceProviderBoostedRewardEligibility::RadioThresholdNotMet => {
-                Self::RadioThresholdNotMet
-            }
-            ServiceProviderBoostedRewardEligibility::Eligible => {
+            SPBoostedRewardEligibility::RadioThresholdNotMet => Self::RadioThresholdNotMet,
+            SPBoostedRewardEligibility::Eligible => {
                 // hip-93: if radio is wifi & location_trust score multiplier < 0.75, no boosting
                 if radio_type.is_wifi() && location_trust_multiplier < MIN_WIFI_TRUST_MULTIPLIER {
                     return Self::WifiLocationScoreBelowThreshold(location_trust_multiplier);
@@ -362,7 +358,7 @@ mod tests {
     ) {
         let wifi = CoveragePoints::new(
             RadioType::IndoorWifi,
-            ServiceProviderBoostedRewardEligibility::Eligible,
+            SPBoostedRewardEligibility::Eligible,
             speedtest_maximum(),
             location_trust_maximum(),
             vec![RankedCoverage {
@@ -384,7 +380,7 @@ mod tests {
 
     #[test]
     fn hip_84_radio_meets_minimum_subscriber_threshold_for_boosted_hexes() {
-        let calculate_wifi = |eligibility: ServiceProviderBoostedRewardEligibility| {
+        let calculate_wifi = |eligibility: SPBoostedRewardEligibility| {
             CoveragePoints::new(
                 RadioType::IndoorWifi,
                 eligibility,
@@ -409,13 +405,12 @@ mod tests {
 
         // Radio meeting the threshold is eligible for boosted hexes.
         // Boosted hex provides radio with more than base_points.
-        let verified_wifi = calculate_wifi(ServiceProviderBoostedRewardEligibility::Eligible);
+        let verified_wifi = calculate_wifi(SPBoostedRewardEligibility::Eligible);
         assert_eq!(base_points * dec!(5), verified_wifi.coverage_points_v1());
 
         // Radio not meeting the threshold is not eligible for boosted hexes.
         // Boost from hex is not applied, radio receives base points.
-        let unverified_wifi =
-            calculate_wifi(ServiceProviderBoostedRewardEligibility::RadioThresholdNotMet);
+        let unverified_wifi = calculate_wifi(SPBoostedRewardEligibility::RadioThresholdNotMet);
         assert_eq!(base_points, unverified_wifi.coverage_points_v1());
     }
 
@@ -424,7 +419,7 @@ mod tests {
         let calculate_wifi = |location_trust_scores: Vec<LocationTrust>| {
             CoveragePoints::new(
                 RadioType::IndoorWifi,
-                ServiceProviderBoostedRewardEligibility::Eligible,
+                SPBoostedRewardEligibility::Eligible,
                 speedtest_maximum(),
                 location_trust_scores,
                 vec![RankedCoverage {
@@ -462,7 +457,7 @@ mod tests {
         let calculate_wifi = |location_trust_scores: Vec<LocationTrust>| {
             CoveragePoints::new(
                 RadioType::IndoorWifi,
-                ServiceProviderBoostedRewardEligibility::Eligible,
+                SPBoostedRewardEligibility::Eligible,
                 speedtest_maximum(),
                 location_trust_scores,
                 vec![RankedCoverage {
@@ -498,7 +493,7 @@ mod tests {
         let calculate_indoor_cbrs = |speedtests: Vec<Speedtest>| {
             CoveragePoints::new(
                 RadioType::IndoorCbrs,
-                ServiceProviderBoostedRewardEligibility::Eligible,
+                SPBoostedRewardEligibility::Eligible,
                 speedtests,
                 location_trust_maximum(),
                 vec![RankedCoverage {
@@ -586,7 +581,7 @@ mod tests {
         use Assignment::*;
         let indoor_cbrs = CoveragePoints::new(
             RadioType::IndoorCbrs,
-            ServiceProviderBoostedRewardEligibility::Eligible,
+            SPBoostedRewardEligibility::Eligible,
             speedtest_maximum(),
             location_trust_maximum(),
             vec![
@@ -643,7 +638,7 @@ mod tests {
     ) {
         let outdoor_wifi = CoveragePoints::new(
             radio_type,
-            ServiceProviderBoostedRewardEligibility::Eligible,
+            SPBoostedRewardEligibility::Eligible,
             speedtest_maximum(),
             location_trust_maximum(),
             vec![RankedCoverage {
@@ -672,7 +667,7 @@ mod tests {
     ) {
         let indoor_wifi = CoveragePoints::new(
             radio_type,
-            ServiceProviderBoostedRewardEligibility::Eligible,
+            SPBoostedRewardEligibility::Eligible,
             speedtest_maximum(),
             location_trust_maximum(),
             vec![
@@ -715,7 +710,7 @@ mod tests {
         // Location scores are averaged together
         let indoor_wifi = CoveragePoints::new(
             RadioType::IndoorWifi,
-            ServiceProviderBoostedRewardEligibility::Eligible,
+            SPBoostedRewardEligibility::Eligible,
             speedtest_maximum(),
             location_trust_with_scores(&[dec!(0.1), dec!(0.2), dec!(0.3), dec!(0.4)]),
             vec![RankedCoverage {
@@ -759,7 +754,7 @@ mod tests {
         ];
         let indoor_wifi = CoveragePoints::new(
             RadioType::IndoorWifi,
-            ServiceProviderBoostedRewardEligibility::Eligible,
+            SPBoostedRewardEligibility::Eligible,
             speedtest_maximum(),
             location_trust_maximum(),
             covered_hexes.clone(),
@@ -782,7 +777,7 @@ mod tests {
     ) {
         let outdoor_cbrs = CoveragePoints::new(
             RadioType::OutdoorCbrs,
-            ServiceProviderBoostedRewardEligibility::Eligible,
+            SPBoostedRewardEligibility::Eligible,
             speedtest_maximum(),
             location_trust_maximum(),
             vec![RankedCoverage {
@@ -809,7 +804,7 @@ mod tests {
     ) {
         let indoor_cbrs = CoveragePoints::new(
             RadioType::IndoorCbrs,
-            ServiceProviderBoostedRewardEligibility::Eligible,
+            SPBoostedRewardEligibility::Eligible,
             speedtest_maximum(),
             location_trust_maximum(),
             vec![RankedCoverage {
@@ -838,7 +833,7 @@ mod tests {
     ) {
         let outdoor_wifi = CoveragePoints::new(
             RadioType::OutdoorWifi,
-            ServiceProviderBoostedRewardEligibility::Eligible,
+            SPBoostedRewardEligibility::Eligible,
             speedtest_maximum(),
             location_trust_maximum(),
             vec![RankedCoverage {
@@ -865,7 +860,7 @@ mod tests {
     ) {
         let indoor_wifi = CoveragePoints::new(
             RadioType::IndoorWifi,
-            ServiceProviderBoostedRewardEligibility::Eligible,
+            SPBoostedRewardEligibility::Eligible,
             speedtest_maximum(),
             location_trust_maximum(),
             vec![RankedCoverage {
@@ -890,7 +885,7 @@ mod tests {
             trust_score: dec!(0.0),
         }];
 
-        let wifi_bad_trust_score = |sp_status: ServiceProviderBoostedRewardEligibility| {
+        let wifi_bad_trust_score = |sp_status: SPBoostedRewardEligibility| {
             BoostedHexStatus::new(
                 RadioType::IndoorWifi,
                 location::multiplier(RadioType::IndoorWifi, &bad_location),
@@ -900,15 +895,15 @@ mod tests {
         };
 
         assert_eq!(
-            wifi_bad_trust_score(ServiceProviderBoostedRewardEligibility::Eligible),
+            wifi_bad_trust_score(SPBoostedRewardEligibility::Eligible),
             BoostedHexStatus::WifiLocationScoreBelowThreshold(dec!(0)),
         );
         assert_eq!(
-            wifi_bad_trust_score(ServiceProviderBoostedRewardEligibility::ServiceProviderBanned),
+            wifi_bad_trust_score(SPBoostedRewardEligibility::ServiceProviderBanned),
             BoostedHexStatus::ServiceProviderBanned
         );
         assert_eq!(
-            wifi_bad_trust_score(ServiceProviderBoostedRewardEligibility::RadioThresholdNotMet),
+            wifi_bad_trust_score(SPBoostedRewardEligibility::RadioThresholdNotMet),
             BoostedHexStatus::RadioThresholdNotMet
         );
     }

diff --git a/coverage_point_calculator/src/service_provider_boosting.rs b/coverage_point_calculator/src/service_provider_boosting.rs
@@ -20,7 +20,7 @@ pub(crate) const MIN_WIFI_TRUST_MULTIPLIER: Decimal = dec!(0.75);
 pub(crate) const MAX_AVERAGE_DISTANCE: Decimal = dec!(50);
 
 #[derive(Debug, Clone, Copy, PartialEq)]
-pub enum ServiceProviderBoostedRewardEligibility {
+pub enum SPBoostedRewardEligibility {
     Eligible,
     /// Service Provider can invalidate boosted rewards of a hotspot
     ///

diff --git a/coverage_point_calculator/tests/coverage_point_calculator.rs b/coverage_point_calculator/tests/coverage_point_calculator.rs
@@ -3,8 +3,8 @@ use std::num::NonZeroU32;
 use chrono::Utc;
 use coverage_map::{BoostedHexMap, RankedCoverage, SignalLevel, UnrankedCoverage};
 use coverage_point_calculator::{
-    BytesPs, CoveragePoints, LocationTrust, RadioType, Result,
-    ServiceProviderBoostedRewardEligibility, Speedtest, SpeedtestTier,
+    BytesPs, CoveragePoints, LocationTrust, RadioType, Result, SPBoostedRewardEligibility,
+    Speedtest, SpeedtestTier,
 };
 use hex_assignments::{assignment::HexAssignments, Assignment};
 use rust_decimal_macros::dec;
@@ -52,7 +52,7 @@ fn base_radio_coverage_points() {
     ] {
         let coverage_points = CoveragePoints::new(
             radio_type,
-            ServiceProviderBoostedRewardEligibility::Eligible,
+            SPBoostedRewardEligibility::Eligible,
             speedtests.clone(),
             location_trust_scores.clone(),
             hexes.clone(),
@@ -113,7 +113,7 @@ fn radios_with_coverage() {
     ] {
         let coverage_points = CoveragePoints::new(
             radio_type,
-            ServiceProviderBoostedRewardEligibility::Eligible,
+            SPBoostedRewardEligibility::Eligible,
             default_speedtests.clone(),
             default_location_trust_scores.clone(),
             base_hex_iter.clone().take(num_hexes).collect(),
@@ -240,7 +240,7 @@ fn cbrs_outdoor_with_mixed_signal_level_coverage() -> Result {
 
     let radio = CoveragePoints::new(
         RadioType::OutdoorCbrs,
-        ServiceProviderBoostedRewardEligibility::Eligible,
+        SPBoostedRewardEligibility::Eligible,
         Speedtest::mock(SpeedtestTier::Good),
         vec![], // Location Trust is ignored for Cbrs
         vec![
@@ -372,7 +372,7 @@ fn indoor_cbrs_radio(
 ) -> Result<CoveragePoints> {
     CoveragePoints::new(
         RadioType::IndoorCbrs,
-        ServiceProviderBoostedRewardEligibility::Eligible,
+        SPBoostedRewardEligibility::Eligible,
         Speedtest::mock(speedtest_tier),
         vec![],
         coverage.to_owned(),
@@ -385,7 +385,7 @@ fn outdoor_cbrs_radio(
 ) -> Result<CoveragePoints> {
     CoveragePoints::new(
         RadioType::OutdoorCbrs,
-        ServiceProviderBoostedRewardEligibility::Eligible,
+        SPBoostedRewardEligibility::Eligible,
         Speedtest::mock(speedtest_tier),
         vec![],
         coverage.to_owned(),

diff --git a/mobile_verifier/src/reward_shares.rs b/mobile_verifier/src/reward_shares.rs
@@ -8,7 +8,7 @@ use crate::{
     subscriber_location::SubscriberValidatedLocations,
 };
 use chrono::{DateTime, Duration, Utc};
-use coverage_point_calculator::ServiceProviderBoostedRewardEligibility;
+use coverage_point_calculator::SPBoostedRewardEligibility;
 use file_store::traits::TimestampEncode;
 use futures::{Stream, StreamExt};
 use helium_crypto::PublicKeyBinary;
@@ -427,7 +427,7 @@ struct RadioInfo {
     coverage_obj_uuid: Uuid,
     seniority: Seniority,
     trust_scores: Vec<coverage_point_calculator::LocationTrust>,
-    sp_boosted_reward_eligibility: ServiceProviderBoostedRewardEligibility,
+    sp_boosted_reward_eligibility: SPBoostedRewardEligibility,
     speedtests: Vec<coverage_point_calculator::Speedtest>,
 }
 
@@ -2035,7 +2035,7 @@ mod test {
                     inserted_at: now,
                     update_reason: 0,
                 },
-                sp_boosted_reward_eligibility: ServiceProviderBoostedRewardEligibility::Eligible,
+                sp_boosted_reward_eligibility: SPBoostedRewardEligibility::Eligible,
                 speedtests: vec![
                     coverage_point_calculator::Speedtest {
                         upload_speed: coverage_point_calculator::BytesPs::new(100_000_000),
@@ -2068,7 +2068,7 @@ mod test {
                     inserted_at: now,
                     update_reason: 0,
                 },
-                sp_boosted_reward_eligibility: ServiceProviderBoostedRewardEligibility::Eligible,
+                sp_boosted_reward_eligibility: SPBoostedRewardEligibility::Eligible,
                 speedtests: vec![],
             },
         );

diff --git a/mobile_verifier/src/rewarder/boosted_hex_eligibility.rs b/mobile_verifier/src/rewarder/boosted_hex_eligibility.rs
@@ -1,4 +1,4 @@
-use coverage_point_calculator::ServiceProviderBoostedRewardEligibility;
+use coverage_point_calculator::SPBoostedRewardEligibility;
 use helium_crypto::PublicKeyBinary;
 
 use crate::{radio_threshold::VerifiedRadioThresholds, sp_boosted_rewards_bans::BannedRadios};
@@ -21,13 +21,13 @@ impl BoostedHexEligibility {
         &self,
         key: PublicKeyBinary,
         cbsd_id_opt: Option<String>,
-    ) -> ServiceProviderBoostedRewardEligibility {
+    ) -> SPBoostedRewardEligibility {
         if self.banned_radios.contains(&key, cbsd_id_opt.as_deref()) {
-            ServiceProviderBoostedRewardEligibility::ServiceProviderBanned
+            SPBoostedRewardEligibility::ServiceProviderBanned
         } else if self.radio_thresholds.is_verified(key, cbsd_id_opt) {
-            ServiceProviderBoostedRewardEligibility::Eligible
+            SPBoostedRewardEligibility::Eligible
         } else {
-            ServiceProviderBoostedRewardEligibility::RadioThresholdNotMet
+            SPBoostedRewardEligibility::RadioThresholdNotMet
         }
     }
 }
@@ -56,14 +56,14 @@ mod tests {
         let eligibility = boosted_hex_eligibility.eligibility(pub_key.clone(), None);
 
         assert_eq!(
-            ServiceProviderBoostedRewardEligibility::ServiceProviderBanned,
+            SPBoostedRewardEligibility::ServiceProviderBanned,
             eligibility
         );
 
         let eligibility = boosted_hex_eligibility.eligibility(pub_key, Some(cbsd_id));
 
         assert_eq!(
-            ServiceProviderBoostedRewardEligibility::ServiceProviderBanned,
+            SPBoostedRewardEligibility::ServiceProviderBanned,
             eligibility
         );
     }
@@ -81,14 +81,14 @@ mod tests {
         let eligibility = boosted_hex_eligibility.eligibility(pub_key.clone(), None);
 
         assert_eq!(
-            ServiceProviderBoostedRewardEligibility::RadioThresholdNotMet,
+            SPBoostedRewardEligibility::RadioThresholdNotMet,
             eligibility
         );
 
         let eligibility = boosted_hex_eligibility.eligibility(pub_key, Some(cbsd_id));
 
         assert_eq!(
-            ServiceProviderBoostedRewardEligibility::RadioThresholdNotMet,
+            SPBoostedRewardEligibility::RadioThresholdNotMet,
             eligibility
         );
     }
@@ -109,17 +109,11 @@ mod tests {
 
         let eligibility = boosted_hex_eligibility.eligibility(pub_key.clone(), None);
 
-        assert_eq!(
-            ServiceProviderBoostedRewardEligibility::Eligible,
-            eligibility
-        );
+        assert_eq!(SPBoostedRewardEligibility::Eligible, eligibility);
 
         let eligibility = boosted_hex_eligibility.eligibility(pub_key, Some(cbsd_id));
 
-        assert_eq!(
-            ServiceProviderBoostedRewardEligibility::Eligible,
-            eligibility
-        );
+        assert_eq!(SPBoostedRewardEligibility::Eligible, eligibility);
     }
 
     fn generate_keypair() -> Keypair {