verify asserted device type against wifi HB cell type

Cargo.toml

@@ -61,14 +61,14 @@ sqlx = {version = "0", features = [
 ]}
 
 helium-crypto = {version = "0.8.1", features=["sqlx-postgres", "multisig"]}
-helium-proto = {git = "https://github.com/helium/proto", branch = "master", features = ["services"]}
+helium-proto = {git = "https://github.com/helium/proto", branch = "andymck/verify-hb-cell-type", features = ["services"]}
 hextree = "*"
 solana-client = "1.14"
 solana-sdk = "1.14"
 solana-program = "1.11"
 spl-token = "3.5.0"
 reqwest = {version = "0", default-features=false, features = ["gzip", "json", "rustls-tls"]}
-beacon = { git = "https://github.com/helium/proto", branch = "master" }
+beacon = { git = "https://github.com/helium/proto", branch = "andymck/verify-hb-cell-type" }
 humantime = "2"
 metrics = "0"
 metrics-exporter-prometheus = "0"

mobile_config/src/gateway_info.rs

@@ -3,12 +3,12 @@ use helium_crypto::PublicKeyBinary;
 use helium_proto::services::mobile_config::{
     GatewayInfo as GatewayInfoProto, GatewayMetadata as GatewayMetadataProto,
 };
-
 pub type GatewayInfoStream = BoxStream<'static, GatewayInfo>;
 
 #[derive(Clone, Debug)]
 pub struct GatewayMetadata {
     pub location: u64,
+    pub device_type: String,
 }
 
 #[derive(Clone, Debug)]
@@ -33,11 +33,15 @@ impl From<GatewayInfoProto> for GatewayInfo {
     fn from(info: GatewayInfoProto) -> Self {
         let metadata = if let Some(metadata) = info.metadata {
             u64::from_str_radix(&metadata.location, 16)
-                .map(|location| GatewayMetadata { location })
+                .map(|location| GatewayMetadata {
+                    location,
+                    device_type: metadata.device_type,
+                })
                 .ok()
         } else {
             None
         };
+
         Self {
             address: info.address.into(),
             metadata,
@@ -52,6 +56,7 @@ impl TryFrom<GatewayInfo> for GatewayInfoProto {
         let metadata = if let Some(metadata) = info.metadata {
             Some(GatewayMetadataProto {
                 location: hextree::Cell::from_raw(metadata.location)?.to_string(),
+                device_type: metadata.device_type,
             })
         } else {
             None
@@ -67,11 +72,12 @@ pub(crate) mod db {
     use super::{GatewayInfo, GatewayMetadata};
     use futures::stream::{Stream, StreamExt};
     use helium_crypto::PublicKeyBinary;
+    use sqlx::types::Json;
     use sqlx::{PgExecutor, Row};
     use std::str::FromStr;
 
     const GET_METADATA_SQL: &str = r#"
-            select kta.entity_key, infos.location::bigint
+            select kta.entity_key, infos.location::bigint, infos.device_type
             from mobile_hotspot_infos infos
             join key_to_assets kta on infos.asset = kta.asset
         "#;
@@ -102,10 +108,12 @@ pub(crate) mod db {
 
     impl sqlx::FromRow<'_, sqlx::postgres::PgRow> for GatewayInfo {
         fn from_row(row: &sqlx::postgres::PgRow) -> sqlx::Result<Self> {
+            let device_type = row.get::<Json<String>, &str>("device_type").to_string();
             let metadata = row
                 .get::<Option<i64>, &str>("location")
                 .map(|loc| GatewayMetadata {
                     location: loc as u64,
+                    device_type,
                 });
             Ok(Self {
                 address: PublicKeyBinary::from_str(

mobile_verifier/src/cell_type.rs

@@ -3,6 +3,7 @@ use helium_proto::services::poc_mobile::CellType as CellTypeProto;
 use rust_decimal::Decimal;
 use rust_decimal_macros::dec;
 use serde::Serialize;
+use std::str::FromStr;
 
 pub const CELLTYPE_NOVA_436H: &str = "2AG32MBS3100196N";
 pub const CELLTYPE_NOVA_430I: &str = "2AG32PBS3101S";
@@ -27,7 +28,7 @@ pub enum CellType {
 pub enum CellTypeLabel {
     CellTypeLabelNone = 0,
     CBRS = 1,
-    Wifi = 2,
+    WifiIndoor = 2,
 }
 
 impl CellType {
@@ -50,7 +51,7 @@ impl CellType {
             Self::SercommIndoor => CellTypeLabel::CBRS,
             Self::SercommOutdoor => CellTypeLabel::CBRS,
             Self::CellTypeNone => CellTypeLabel::CellTypeLabelNone,
-            Self::NovaGenericWifiIndoor => CellTypeLabel::Wifi,
+            Self::NovaGenericWifiIndoor => CellTypeLabel::WifiIndoor,
         }
     }
 
@@ -102,3 +103,14 @@ impl From<CellType> for CellTypeProto {
         }
     }
 }
+
+impl FromStr for CellTypeLabel {
+    type Err = anyhow::Error;
+    fn from_str(s: &str) -> anyhow::Result<CellTypeLabel> {
+        match s {
+            "wifiIndoor" => Ok(CellTypeLabel::WifiIndoor),
+            "cbrs" => Ok(CellTypeLabel::CBRS),
+            _ => anyhow::bail!("unknown cell type"),
+        }
+    }
+}

mobile_verifier/src/heartbeats/mod.rs

@@ -19,7 +19,7 @@ use helium_proto::services::poc_mobile as proto;
 use retainer::Cache;
 use rust_decimal::{prelude::ToPrimitive, Decimal};
 use sqlx::{postgres::PgTypeInfo, Decode, Encode, Postgres, Transaction, Type};
-use std::{ops::Range, pin::pin, time};
+use std::{ops::Range, pin::pin, str::FromStr, time};
 use uuid::Uuid;
 
 /// Minimum number of heartbeats required to give a reward to the hotspot.
@@ -247,7 +247,7 @@ impl HeartbeatReward {
                 .cbsd_id
                 .clone()
                 .ok_or_else(|| anyhow!("expected cbsd_id, found none"))?),
-            CellTypeLabel::Wifi => Ok(self.hotspot_key.to_string()),
+            CellTypeLabel::WifiIndoor => Ok(self.hotspot_key.to_string()),
             _ => Err(anyhow!("failed to derive label from cell type")),
         }
     }
@@ -504,8 +504,15 @@ pub async fn validate_heartbeat(
                 proto::HeartbeatValidity::GatewayNotAsserted,
             ))
         }
-        GatewayResolution::AssertedLocation(location) if heartbeat.hb_type == HbType::Wifi => {
-            Some(heartbeat.asserted_distance(location)?)
+        GatewayResolution::GatewayAsserted(metadata) if heartbeat.hb_type == HbType::Wifi => {
+            // for wifi HBs, check the asserted device type matches that defined in the HB
+            let asserted_celltype_label = CellTypeLabel::from_str(&metadata.device_type)?;
+            if asserted_celltype_label == CellTypeLabel::WifiIndoor
+                && cell_type.to_label() != asserted_celltype_label
+            {
+                return Ok((cell_type, None, None, proto::HeartbeatValidity::BadCellType));
+            };
+            Some(heartbeat.asserted_distance(metadata.location)?)
         }
         _ => None,
     };
@@ -529,7 +536,6 @@ pub async fn validate_heartbeat(
 
     let Ok(latlng) = LatLng::new(heartbeat.report.lat, heartbeat.report.lon) else {
         return Ok((cell_type, None, proto::HeartbeatValidity::InvalidLatLon));
-    };
 
     if coverage.max_distance_km(latlng) > max_distance {
         return Ok((

mobile_verifier/src/lib.rs

@@ -15,10 +15,11 @@ pub use settings::Settings;
 
 use async_trait::async_trait;
 
+use mobile_config::gateway_info::GatewayMetadata;
 pub enum GatewayResolution {
     GatewayNotFound,
     GatewayNotAsserted,
-    AssertedLocation(u64),
+    GatewayAsserted(GatewayMetadata),
 }
 
 #[async_trait]
@@ -45,7 +46,7 @@ impl GatewayResolver for mobile_config::GatewayClient {
             Some(GatewayInfo {
                 metadata: Some(metadata),
                 ..
-            }) => Ok(GatewayResolution::AssertedLocation(metadata.location)),
+            }) => Ok(GatewayResolution::GatewayAsserted(metadata)),
             Some(_) => Ok(GatewayResolution::GatewayNotAsserted),
         }
     }