clean up exported naming from service provider

mobile_verifier/src/reward_shares.rs

@@ -772,8 +772,7 @@ mod test {
         heartbeats::{HeartbeatReward, KeyType, OwnedKeyType},
         reward_shares,
         service_provider::{
-            self, dc_sessions::ServiceProviderDCSessions, promotions::ServiceProviderPromotions,
-            ServiceProviderRewardInfos,
+            self, ServiceProviderDCSessions, ServiceProviderPromotions, ServiceProviderRewardInfos,
         },
         speedtests::Speedtest,
         speedtests_average::SpeedtestAverage,

mobile_verifier/src/rewarder.rs

@@ -7,9 +7,7 @@ use crate::{
         self, CalculatedPocRewardShares, CoverageShares, DataTransferAndPocAllocatedRewardBuckets,
         MapperShares, TransferRewards,
     },
-    service_provider::{
-        self, dc_sessions::ServiceProviderDCSessions, promotions::ServiceProviderPromotions,
-    },
+    service_provider::{self, ServiceProviderDCSessions, ServiceProviderPromotions},
     sp_boosted_rewards_bans, speedtests,
     speedtests_average::SpeedtestAverages,
     subscriber_location, subscriber_verified_mapping_event, telemetry, Settings,
@@ -276,16 +274,13 @@ where
         reward_mappers(&self.pool, &self.mobile_rewards, reward_period).await?;
 
         // process rewards for service providers
-        let dc_sessions = service_provider::db::fetch_dc_sessions(
-            &self.pool,
-            &self.carrier_client,
-            reward_period,
-        )
-        .await?;
-        let sp_promotions = self.carrier_client.list_incentive_promotions().await?;
+        let dc_sessions =
+            service_provider::get_dc_sessions(&self.pool, &self.carrier_client, reward_period)
+                .await?;
+        let sp_promotions = service_provider::get_promotions(&self.carrier_client).await?;
         reward_service_providers(
             dc_sessions,
-            sp_promotions.clone().into(),
+            sp_promotions.clone(),
             &self.mobile_rewards,
             reward_period,
             mobile_bone_price,
@@ -321,7 +316,7 @@ where
             boosted_poc_bones_per_reward_share: Some(helium_proto::Decimal {
                 value: poc_dc_shares.boost.to_string(),
             }),
-            sp_promotions,
+            sp_promotions: sp_promotions.into_proto(),
         };
         self.reward_manifests
             .write(

mobile_verifier/src/service_provider/dc_sessions.rs

@@ -12,7 +12,7 @@ use crate::{
 
 use super::ServiceProviderId;
 
-pub async fn fetch_dc_sessions(
+pub async fn get_dc_sessions(
     pool: &PgPool,
     carrier_client: &impl CarrierServiceVerifier<Error = ClientError>,
     reward_period: &Range<DateTime<Utc>>,
@@ -167,7 +167,7 @@ pub mod tests {
         let epoch = now - Duration::hours(24)..now;
 
         // dc sessions should represent single payer, and all dc is combined
-        let map = fetch_dc_sessions(&pool, &MockClient, &epoch).await?;
+        let map = get_dc_sessions(&pool, &MockClient, &epoch).await?;
         assert_eq!(map.len(), 1);
         assert_eq!(map.all_transfer(), Decimal::from(4_000));
 

mobile_verifier/src/service_provider/mod.rs

@@ -1,15 +1,14 @@
 use std::ops::Range;
 
 use chrono::{DateTime, Utc};
-pub use reward::ServiceProviderRewardInfos;
 
-pub mod dc_sessions;
-pub mod promotions;
-pub mod reward;
+pub use dc_sessions::{get_dc_sessions, ServiceProviderDCSessions};
+pub use promotions::{get_promotions, ServiceProviderPromotions};
+pub use reward::ServiceProviderRewardInfos;
 
-pub mod db {
-    pub use super::dc_sessions::fetch_dc_sessions;
-}
+mod dc_sessions;
+mod promotions;
+mod reward;
 
 // This type is used in lieu of the helium_proto::ServiceProvider enum so we can
 // handle more than a single value without adding a hard deploy dependency to

mobile_verifier/src/service_provider/promotions.rs

@@ -1,3 +1,4 @@
+use mobile_config::client::{carrier_service_client::CarrierServiceVerifier, ClientError};
 use rust_decimal::Decimal;
 use rust_decimal_macros::dec;
 
@@ -7,10 +8,21 @@ mod proto {
     pub use helium_proto::{Promotion, ServiceProviderPromotion};
 }
 
-#[derive(Debug, Default)]
-pub struct ServiceProviderPromotions(pub(crate) Vec<proto::ServiceProviderPromotion>);
+pub async fn get_promotions(
+    client: &impl CarrierServiceVerifier<Error = ClientError>,
+) -> anyhow::Result<ServiceProviderPromotions> {
+    let promos = client.list_incentive_promotions().await?;
+    Ok(ServiceProviderPromotions(promos))
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct ServiceProviderPromotions(Vec<proto::ServiceProviderPromotion>);
 
 impl ServiceProviderPromotions {
+    pub fn into_proto(self) -> Vec<proto::ServiceProviderPromotion> {
+        self.0
+    }
+
     pub(crate) fn get_fund_percent(&self, sp_id: ServiceProviderId) -> Decimal {
         for promo in &self.0 {
             if promo.service_provider == sp_id {

mobile_verifier/tests/integrations/rewarder_sp_rewards.rs

@@ -15,9 +15,7 @@ use sqlx::{PgPool, Postgres, Transaction};
 
 use crate::common::{self, MockFileSinkReceiver};
 use mobile_config::client::{carrier_service_client::CarrierServiceVerifier, ClientError};
-use mobile_verifier::{
-    data_session, reward_shares, rewarder, service_provider::db::fetch_dc_sessions,
-};
+use mobile_verifier::{data_session, reward_shares, rewarder, service_provider};
 
 const HOTSPOT_1: &str = "112NqN2WWMwtK29PMzRby62fDydBJfsCLkCAf392stdok48ovNT6";
 const HOTSPOT_2: &str = "11eX55faMbqZB7jzN4p67m6w7ScPMH6ubnvCjCPLh72J49PaJEL";
@@ -83,7 +81,7 @@ async fn test_service_provider_rewards(pool: PgPool) -> anyhow::Result<()> {
     seed_hotspot_data(epoch.end, &mut txn).await?;
     txn.commit().await?;
 
-    let dc_sessions = fetch_dc_sessions(&pool, &carrier_client, &epoch).await?;
+    let dc_sessions = service_provider::get_dc_sessions(&pool, &carrier_client, &epoch).await?;
     let sp_promotions = carrier_client.list_incentive_promotions().await?;
 
     let (_, rewards) = tokio::join!(
@@ -145,7 +143,7 @@ async fn test_service_provider_rewards_halt_on_invalid_sp(pool: PgPool) -> anyho
     seed_hotspot_data_invalid_sp(epoch.end, &mut txn).await?;
     txn.commit().await.expect("db txn failed");
 
-    let dc_sessions = fetch_dc_sessions(&pool, &carrier_client, &epoch).await;
+    let dc_sessions = service_provider::get_dc_sessions(&pool, &carrier_client, &epoch).await;
     assert_eq!(
         dc_sessions.unwrap_err().to_string(),
         format!("unknown service provider {PAYER_2}")
@@ -194,7 +192,7 @@ async fn test_service_provider_promotion_rewards(pool: PgPool) -> anyhow::Result
 
     txn.commit().await?;
 
-    let dc_sessions = fetch_dc_sessions(&pool, &carrier_client, &epoch).await?;
+    let dc_sessions = service_provider::get_dc_sessions(&pool, &carrier_client, &epoch).await?;
     let sp_promotions = carrier_client.list_incentive_promotions().await?;
 
     let (_, rewards) = tokio::join!(