finished with the route

Author: simzzz

primitives/src/sentry.rs

@@ -203,6 +203,11 @@ pub struct SpenderResponse {
     pub spender_leaf: Option<SpenderLeaf>,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct AllSpendersResponse {
+    pub spenders: Option<HashMap<Address, SpenderResponse>>,
+}
+
 // TODO: Maybe there is a better place for this struct
 #[derive(Serialize, Deserialize, Debug)]
 pub struct SpenderLeaf {

sentry/src/db/accounting.rs

@@ -2,7 +2,6 @@ use std::convert::TryFrom;
 
 use chrono::{DateTime, Utc};
 use primitives::{
-    balances_map::UnifiedMap,
     channel_v5::Channel,
     sentry::accounting::{Accounting, Balances, CheckedState},
     Address, ChannelId, UnifiedNum,
@@ -65,19 +64,6 @@ async fn insert_accounting(
     Accounting::try_from(&row).map_err(Error::Balances)
 }
 
-async fn get_spenders_for_channel(pool: DbPool, channel_id: &ChannelId) {
-    let client = pool.get().await?;
-
-    let statement = client
-        .prepare("SELECT spenders FROM accounting WHERE channel_id = $1")
-        .await?;
-
-    let rows = client.query(&statement, &[channel_id]).await?;
-    let spenders: UnifiedMap = serde_json::from_value(rows)?;
-
-    Ok(spenders)
-}
-
 #[cfg(test)]
 mod test {
     use primitives::util::tests::prep_db::{ADDRESSES, DUMMY_CAMPAIGN};

sentry/src/lib.rs

@@ -25,7 +25,8 @@ use routes::analytics::{advanced_analytics, advertiser_analytics, analytics, pub
 use routes::campaign::{create_campaign, update_campaign};
 use routes::cfg::config;
 use routes::channel::{
-    channel_list, channel_validate, create_channel, create_validator_messages, last_approved, get_spender_limits, get_all_spender_limits
+    channel_list, channel_validate, create_channel, create_validator_messages,
+    get_all_spender_limits, get_spender_limits, last_approved,
 };
 use slog::Logger;
 use std::collections::HashMap;
@@ -398,10 +399,11 @@ async fn channels_router<A: Adapter + 'static>(
         req = ChannelLoad.call(req, app).await?;
 
         get_spender_limits(req, app).await
-    } else if let(Some(caps), &Method::GET) = (CHANNEL_ALL_SPENDER_LIMITS.captures(&path), method) {
+    } else if let (Some(caps), &Method::GET) = (CHANNEL_ALL_SPENDER_LIMITS.captures(&path), method)
+    {
         req = AuthRequired.call(req, app).await?;
 
-        let param = let param = RouteParams(vec![caps
+        let param = RouteParams(vec![caps
             .get(1)
             .map_or("".to_string(), |m| m.as_str().to_string())]);
         req.extensions_mut().insert(param);

sentry/src/routes/channel.rs

@@ -12,12 +12,12 @@ use primitives::{
     adapter::Adapter,
     sentry::{
         channel_list::{ChannelListQuery, LastApprovedQuery},
-        LastApproved, LastApprovedResponse, SuccessResponse, SpenderLeaf, SpenderResponse
+        LastApproved, LastApprovedResponse, MessageResponse, SuccessResponse, SpenderLeaf, SpenderResponse, AllSpendersResponse
     },
     spender::{Spendable, Deposit},
-    validator::MessageTypes,
+    validator::{MessageTypes, NewState},
     channel_v5::Channel as ChannelV5,
-    Address, Channel, ChannelId, UnifiedNum
+    Address, BigNum, Channel, ChannelId, UnifiedNum
 };
 use slog::error;
 use std::{
@@ -273,25 +273,7 @@ pub async fn get_spender_limits<A: Adapter + 'static>(
     let channel_id = ChannelId::from_hex(route_params.index(0))?;
     let spender = Address::from_str(&route_params.index(1))?;
 
-    let default_response = Response::builder()
-        .header("Content-type", "application/json")
-        .body(
-            serde_json::to_string(&SpenderResponse {
-                total_deposited: None,
-                spender_leaf: None,
-            })?
-            .into(),
-        )
-        .expect("should build response");
-
-    let approve_state = match latest_approve_state_v5(&app.pool, &channel).await? {
-        Some(approve_state) => approve_state,
-        None => return Ok(default_response),
-    };
-
-    let state_root = approve_state.msg.state_root.clone();
-
-    let new_state = latest_new_state_v5(&app.pool, &channel, &state_root).await?.ok_or(ResponseError::BadRequest("non-existing NewState".to_string()))?;
+    let new_state = get_corresponding_new_state(&app.pool, &channel).await.ok_or_else(|| ResponseError::NotFound)?;
 
     let latest_spendable = fetch_spendable(app.pool.clone(), &spender, &channel_id)
         .await?;
@@ -306,54 +288,98 @@ pub async fn get_spender_limits<A: Adapter + 'static>(
     // Calculate total_spent
     let spender_balance = new_state.msg.balances.get(&spender).ok_or_else(|| ResponseError::BadRequest("No balance for this spender".to_string()))?;
 
-    let spender_balance = UnifiedNum::from_u64(spender_balance.to_u64().expect("Consider replacing this in a way that uses UnifiedMap"));
-    let total_spent = total_deposited.checked_sub(&spender_balance).ok_or_else(|| ResponseError::BadRequest("Total spent is too large".to_string()))?;
-
-    let spender_leaf = SpenderLeaf {
-        total_spent,
-        // merkle_proof: [u8; 32], // TODO
-    };
+    // TODO: Maybe throw error if None?
+    let spender_leaf = get_spender_leaf_for_spender(spender_balance, &total_deposited);
 
     // Return
     let res = SpenderResponse {
         total_deposited: Some(total_deposited),
-        spender_leaf: Some(spender_leaf),
+        spender_leaf,
     };
     Ok(success_response(serde_json::to_string(&res)?))
 }
+
 pub async fn get_all_spender_limits<A: Adapter + 'static>(
     req: Request<Body>,
     app: &Application<A>,
 ) -> Result<Response<Body>, ResponseError> {
-    let route_params = req
-        .extensions()
-        .get::<RouteParams>()
-        .expect("request should have route params");
-
     let channel = req
         .extensions()
         .get::<ChannelV5>()
         .expect("Request should have Channel")
         .to_owned();
 
-    // Get all spenders for this channel
+    let new_state = get_corresponding_new_state(&app.pool, &channel).await.ok_or_else(|| ResponseError::NotFound)?;
+
+    let mut all_spender_limits: HashMap<Address, SpenderResponse> = HashMap::new();
+
+    // Using for loop to avoid async closures
+    for (spender, balance) in new_state.msg.balances.iter() {
+        let latest_spendable = fetch_spendable(app.pool.clone(), &spender, &channel.id()).await.expect("todo: fix");
+
+        let latest_spendable = match latest_spendable {
+            Some(spendable) => spendable,
+            None => create_spendable_document(&app.adapter, app.pool.clone(), &channel, &spender).await.expect("todo"),
+        };
+
+        let total_deposited = latest_spendable.deposit.total.checked_add(&latest_spendable.deposit.still_on_create2).ok_or_else(|| ResponseError::BadRequest("Total Deposited is too large".to_string())).expect("todo");
+
+        // TODO: Maybe throw error if None?
+        let spender_leaf = get_spender_leaf_for_spender(balance, &total_deposited);
+
+        let spender_response = SpenderResponse {
+            total_deposited: Some(total_deposited),
+            spender_leaf,
+        };
 
-    // Calculate spender limits for every spender
+        all_spender_limits.insert(spender.clone(), spender_response);
+    }
 
     // Format and return output
 
-    let default_response = Response::builder()
-        .header("Content-type", "application/json")
-        .body(
-            serde_json::to_string(&LastApprovedResponse {
-                last_approved: None,
-                heartbeats: None,
-            })?
-            .into(),
-        )
-        .expect("should build response");
+    let res = AllSpendersResponse {
+        spenders: Some(all_spender_limits),
+    };
+
+    Ok(success_response(serde_json::to_string(&res)?))
+}
+
+async fn get_corresponding_new_state(pool: &DbPool, channel: &ChannelV5) -> Option<MessageResponse<NewState>> {
+    // Get all spenders for this channel
+    let approve_state = match latest_approve_state_v5(&pool, &channel).await {
+        Ok(Some(approve_state)) => approve_state,
+        _ => return None,
+    };
+
+    let state_root = approve_state.msg.state_root.clone();
+
+    let new_state = match latest_new_state_v5(&pool, &channel, &state_root).await {
+        Ok(Some(new_state)) => Some(new_state),
+        _ => None,
+    };
+
+    new_state
+}
+
+// TODO pass UnifiedNum instead
+fn get_spender_leaf_for_spender(spender_balance: &BigNum, total_deposited: &UnifiedNum) -> Option<SpenderLeaf> {
+    let spender_balance = match spender_balance.to_u64() {
+        Some(balance) => UnifiedNum::from_u64(balance),
+        None => return None,
+    };
+
+    let total_spent = match total_deposited.checked_sub(&spender_balance) {
+        Some(spent) => spent,
+        None => return None,
+    };
+
+    // Return
+    let leaf = SpenderLeaf {
+        total_spent,
+        // merkle_proof: [u8; 32], // TODO
+    };
 
-    Ok(success_response(serde_json::to_string(&default_response)?))
+    Some(leaf)
 }
 
 #[cfg(test)]