refactor: remove unwraps

Signed-off-by: Gustavo Inacio <[email protected]>

Author: gusinacio

common/src/allocations/monitor.rs

@@ -9,15 +9,15 @@ use std::{
 
 use super::Allocation;
 use crate::prelude::SubgraphClient;
-use alloy::primitives::U256;
+use alloy::primitives::{TxHash, B256, U256};
 use eventuals::{timer, Eventual, EventualExt};
 use graphql_client::GraphQLQuery;
 use thegraph_core::{Address, DeploymentId};
 use tokio::time::sleep;
 use tracing::warn;
 
-type BigInt = String;
-type Bytes = String;
+type BigInt = U256;
+type Bytes = B256;
 
 #[derive(GraphQLQuery)]
 #[graphql(
@@ -42,9 +42,9 @@ impl TryFrom<allocations_query::AllocationFragment> for Allocation {
                 denied_at: Some(value.subgraph_deployment.denied_at as u64),
             },
             indexer: Address::from_str(&value.indexer.id)?,
-            allocated_tokens: U256::from_str(&value.allocated_tokens)?,
+            allocated_tokens: value.allocated_tokens,
             created_at_epoch: value.created_at_epoch as u64,
-            created_at_block_hash: value.created_at_block_hash,
+            created_at_block_hash: value.created_at_block_hash.to_string(),
             closed_at_epoch: value.closed_at_epoch.map(|v| v as u64),
             closed_at_epoch_start_block_hash: None,
             previous_epoch_start_block_hash: None,
@@ -98,7 +98,7 @@ pub async fn get_allocations(
         .expect("Time went backwards");
     let closed_at_threshold = since_the_epoch - recently_closed_allocation_buffer;
 
-    let mut hash: Option<String> = None;
+    let mut hash: Option<TxHash> = None;
     let mut last: Option<String> = None;
     let mut responses = vec![];
     let page_size = 200;
@@ -129,10 +129,15 @@ pub async fn get_allocations(
             break;
         }
     }
-
-    Ok(HashMap::from_iter(responses.into_iter().map(|a| {
-        (Address::from_str(&a.id).unwrap(), a.try_into().unwrap())
-    })))
+    let responses = responses
+        .into_iter()
+        .map(|allocation| allocation.try_into())
+        .collect::<Result<Vec<Allocation>, _>>()?;
+
+    Ok(responses
+        .into_iter()
+        .map(|allocation| (allocation.id, allocation))
+        .collect())
 }
 
 #[cfg(test)]

common/src/escrow_accounts.rs

@@ -125,7 +125,7 @@ pub fn escrow_accounts(
                 .await
                 .map_err(|e| e.to_string())?;
 
-            let response = response.unwrap();
+            let response = response.map_err(|e| e.to_string())?;
 
             let senders_balances: HashMap<Address, U256> = response
                 .escrow_accounts
@@ -141,27 +141,27 @@ pub fn escrow_accounts(
                             U256::from(0)
                         });
 
-                    Ok((Address::from_str(&account.sender.id).unwrap(), balance))
+                    Ok((Address::from_str(&account.sender.id)?, balance))
                 })
                 .collect::<Result<HashMap<_, _>, anyhow::Error>>()
-                .map_err(|e| format!("{}", e))?;
+                .map_err(|e| e.to_string())?;
 
             let senders_to_signers = response
                 .escrow_accounts
-                .iter()
+                .into_iter()
                 .map(|account| {
-                    let sender = Address::from_str(&account.sender.id).unwrap();
+                    let sender = Address::from_str(&account.sender.id)?;
                     let signers = account
                         .sender
                         .signers
-                        .as_ref()
-                        .unwrap()
+                        .unwrap_or_default()
                         .iter()
-                        .map(|signer| Address::from_str(&signer.id).unwrap())
-                        .collect();
-                    (sender, signers)
+                        .map(|signer| Address::from_str(&signer.id))
+                        .collect::<Result<Vec<_>, _>>()?;
+                    Ok((sender, signers))
                 })
-                .collect();
+                .collect::<Result<HashMap<_, _>, anyhow::Error>>()
+                .map_err(|e| e.to_string())?;
 
             Ok(EscrowAccounts::new(senders_balances, senders_to_signers))
         },

tap-agent/src/agent/sender_account.rs

@@ -384,7 +384,10 @@ impl Actor for SenderAccount {
                     Ok(Ok(response)) => response
                         .transactions
                         .into_iter()
-                        .map(|tx| tx.allocation_id.unwrap())
+                        .map(|tx| {
+                            tx.allocation_id
+                                .expect("all redeem tx must have allocation_id")
+                        })
                         .collect::<Vec<_>>(),
                     // if we have any problems, we don't want to filter out
                     _ => vec![],