style: use fully qualified name for anyhow results

Signed-off-by: Lorenzo Delgado <[email protected]>

Author: LNSD

crates/monitor/src/escrow_accounts.rs

@@ -8,7 +8,7 @@ use std::{
 };
 
 use alloy::primitives::{Address, U256};
-use anyhow::{anyhow, Result};
+use anyhow::anyhow;
 use indexer_query::escrow_account::{self, EscrowAccountQuery};
 use thiserror::Error;
 use tokio::sync::watch::Receiver;
@@ -104,7 +104,7 @@ async fn get_escrow_accounts(
     escrow_subgraph: &'static SubgraphClient,
     indexer_address: Address,
     reject_thawing_signers: bool,
-) -> Result<EscrowAccounts> {
+) -> anyhow::Result<EscrowAccounts> {
     // thawEndTimestamp == 0 means that the signer is not thawing. This also means
     // that we don't wait for the thawing period to end before stopping serving
     // queries for this signer.

crates/tap-agent/src/agent/sender_account.rs

@@ -12,7 +12,6 @@ use alloy::{
     primitives::{Address, U256},
     sol_types::Eip712Domain,
 };
-use anyhow::Result;
 use bigdecimal::{num_bigint::ToBigInt, ToPrimitive};
 use futures::{stream, StreamExt};
 use indexer_monitor::{EscrowAccounts, SubgraphClient};
@@ -215,7 +214,7 @@ impl State {
         &self,
         sender_account_ref: ActorRef<SenderAccountMessage>,
         allocation_id: Address,
-    ) -> Result<()> {
+    ) -> anyhow::Result<()> {
         tracing::trace!(
             %self.sender,
             %allocation_id,
@@ -252,7 +251,7 @@ impl State {
         sender_allocation_id
     }
 
-    async fn rav_request_for_heaviest_allocation(&mut self) -> Result<()> {
+    async fn rav_request_for_heaviest_allocation(&mut self) -> anyhow::Result<()> {
         let allocation_id = self
             .sender_fee_tracker
             .get_heaviest_allocation_id()
@@ -272,7 +271,7 @@ impl State {
         self.rav_request_for_allocation(allocation_id).await
     }
 
-    async fn rav_request_for_allocation(&mut self, allocation_id: Address) -> Result<()> {
+    async fn rav_request_for_allocation(&mut self, allocation_id: Address) -> anyhow::Result<()> {
         let sender_allocation_id = self.format_sender_allocation(&allocation_id);
         let allocation = ActorRef::<SenderAllocationMessage>::where_is(sender_allocation_id);
 
@@ -482,7 +481,7 @@ impl Actor for SenderAccount {
             prefix,
             retry_interval,
         }: Self::Arguments,
-    ) -> std::result::Result<Self::State, ActorProcessingErr> {
+    ) -> Result<Self::State, ActorProcessingErr> {
         let myself_clone = myself.clone();
         let _indexer_allocations_handle = watch_pipe(indexer_allocations, move |allocation_ids| {
             let allocation_ids = allocation_ids.clone();
@@ -651,7 +650,7 @@ impl Actor for SenderAccount {
         myself: ActorRef<Self::Msg>,
         message: Self::Msg,
         state: &mut Self::State,
-    ) -> std::result::Result<(), ActorProcessingErr> {
+    ) -> Result<(), ActorProcessingErr> {
         tracing::span!(
             Level::TRACE,
             "SenderAccount handle()",
@@ -937,7 +936,7 @@ impl Actor for SenderAccount {
         myself: ActorRef<Self::Msg>,
         message: SupervisionEvent,
         state: &mut Self::State,
-    ) -> std::result::Result<(), ActorProcessingErr> {
+    ) -> Result<(), ActorProcessingErr> {
         tracing::trace!(
             sender = %state.sender,
             message = ?message,
@@ -1019,7 +1018,7 @@ impl Actor for SenderAccount {
 }
 
 impl SenderAccount {
-    pub async fn deny_sender(pool: &sqlx::PgPool, sender: Address) {
+    pub async fn deny_sender(pool: &PgPool, sender: Address) {
         sqlx::query!(
             r#"
                     INSERT INTO scalar_tap_denylist (sender_address)

crates/tap-agent/src/agent/sender_accounts_manager.rs

@@ -8,7 +8,7 @@ use std::{
 };
 
 use alloy::{primitives::Address, sol_types::Eip712Domain};
-use anyhow::{anyhow, bail, Result};
+use anyhow::{anyhow, bail};
 use futures::{stream, StreamExt};
 use indexer_allocation::Allocation;
 use indexer_monitor::{EscrowAccounts, SubgraphClient};
@@ -105,7 +105,7 @@ impl Actor for SenderAccountsManager {
             sender_aggregator_endpoints,
             prefix,
         }: Self::Arguments,
-    ) -> std::result::Result<Self::State, ActorProcessingErr> {
+    ) -> Result<Self::State, ActorProcessingErr> {
         let (allocations_tx, allocations_rx) = watch::channel(HashSet::<Address>::new());
         watch_pipe(indexer_allocations.clone(), move |allocation_id| {
             let allocation_set = allocation_id.keys().cloned().collect::<HashSet<Address>>();
@@ -175,7 +175,7 @@ impl Actor for SenderAccountsManager {
         &self,
         _: ActorRef<Self::Msg>,
         state: &mut Self::State,
-    ) -> std::result::Result<(), ActorProcessingErr> {
+    ) -> Result<(), ActorProcessingErr> {
         // Abort the notification watcher on drop. Otherwise it may panic because the PgPool could
         // get dropped before. (Observed in tests)
         if let Some(handle) = &state.new_receipts_watcher_handle {
@@ -189,7 +189,7 @@ impl Actor for SenderAccountsManager {
         myself: ActorRef<Self::Msg>,
         msg: Self::Msg,
         state: &mut Self::State,
-    ) -> std::result::Result<(), ActorProcessingErr> {
+    ) -> Result<(), ActorProcessingErr> {
         tracing::trace!(
             message = ?msg,
             "New SenderAccountManager message"
@@ -226,7 +226,7 @@ impl Actor for SenderAccountsManager {
         myself: ActorRef<Self::Msg>,
         message: SupervisionEvent,
         state: &mut Self::State,
-    ) -> std::result::Result<(), ActorProcessingErr> {
+    ) -> Result<(), ActorProcessingErr> {
         match message {
             SupervisionEvent::ActorTerminated(cell, _, reason) => {
                 let sender_id = cell.get_name();
@@ -440,7 +440,7 @@ impl State {
         &self,
         sender_id: &Address,
         allocation_ids: HashSet<Address>,
-    ) -> Result<SenderAccountArgs> {
+    ) -> anyhow::Result<SenderAccountArgs> {
         Ok(SenderAccountArgs {
             config: self.config,
             pgpool: self.pgpool.clone(),
@@ -519,7 +519,7 @@ async fn handle_notification(
     new_receipt_notification: NewReceiptNotification,
     escrow_accounts_rx: Receiver<EscrowAccounts>,
     prefix: Option<&str>,
-) -> Result<()> {
+) -> anyhow::Result<()> {
     tracing::trace!(
         notification = ?new_receipt_notification,
         "New receipt notification detected!"

crates/tap-agent/src/agent/sender_allocation.rs

@@ -7,7 +7,7 @@ use std::{
 };
 
 use alloy::{hex::ToHexExt, primitives::Address, sol_types::Eip712Domain};
-use anyhow::{anyhow, ensure, Result};
+use anyhow::{anyhow, ensure};
 use bigdecimal::{num_bigint::BigInt, ToPrimitive};
 use indexer_monitor::{EscrowAccounts, SubgraphClient};
 use jsonrpsee::{core::client::ClientT, rpc_params};
@@ -165,7 +165,7 @@ impl Actor for SenderAllocation {
         &self,
         _myself: ActorRef<Self::Msg>,
         args: Self::Arguments,
-    ) -> std::result::Result<Self::State, ActorProcessingErr> {
+    ) -> Result<Self::State, ActorProcessingErr> {
         let sender_account_ref = args.sender_account_ref.clone();
         let allocation_id = args.allocation_id;
         let mut state = SenderAllocationState::new(args).await?;
@@ -207,7 +207,7 @@ impl Actor for SenderAllocation {
         &self,
         _myself: ActorRef<Self::Msg>,
         state: &mut Self::State,
-    ) -> std::result::Result<(), ActorProcessingErr> {
+    ) -> Result<(), ActorProcessingErr> {
         tracing::info!(
             sender = %state.sender,
             allocation_id = %state.allocation_id,
@@ -258,7 +258,7 @@ impl Actor for SenderAllocation {
         _myself: ActorRef<Self::Msg>,
         message: Self::Msg,
         state: &mut Self::State,
-    ) -> std::result::Result<(), ActorProcessingErr> {
+    ) -> Result<(), ActorProcessingErr> {
         tracing::trace!(
             sender = %state.sender,
             allocation_id = %state.allocation_id,
@@ -394,18 +394,21 @@ impl SenderAllocationState {
         })
     }
 
-    async fn recalculate_all_unaggregated_fees(&self) -> Result<UnaggregatedReceipts> {
+    async fn recalculate_all_unaggregated_fees(&self) -> anyhow::Result<UnaggregatedReceipts> {
         self.calculate_fee_until_last_id(i64::MAX).await
     }
 
-    async fn calculate_unaggregated_fee(&self) -> Result<UnaggregatedReceipts> {
+    async fn calculate_unaggregated_fee(&self) -> anyhow::Result<UnaggregatedReceipts> {
         self.calculate_fee_until_last_id(self.unaggregated_fees.last_id as i64)
             .await
     }
 
     /// Delete obsolete receipts in the DB w.r.t. the last RAV in DB, then update the tap manager
     /// with the latest unaggregated fees from the database.
-    async fn calculate_fee_until_last_id(&self, last_id: i64) -> Result<UnaggregatedReceipts> {
+    async fn calculate_fee_until_last_id(
+        &self,
+        last_id: i64,
+    ) -> anyhow::Result<UnaggregatedReceipts> {
         tracing::trace!("calculate_unaggregated_fee()");
         self.tap_manager.remove_obsolete_receipts().await?;
 
@@ -458,7 +461,7 @@ impl SenderAllocationState {
         })
     }
 
-    async fn calculate_invalid_receipts_fee(&self) -> Result<UnaggregatedReceipts> {
+    async fn calculate_invalid_receipts_fee(&self) -> anyhow::Result<UnaggregatedReceipts> {
         tracing::trace!("calculate_invalid_receipts_fee()");
         let signers = signers_trimmed(self.escrow_accounts.clone(), self.sender).await?;
 
@@ -501,7 +504,7 @@ impl SenderAllocationState {
         })
     }
 
-    async fn request_rav(&mut self) -> Result<()> {
+    async fn request_rav(&mut self) -> anyhow::Result<()> {
         match self.rav_requester_single().await {
             Ok(rav) => {
                 self.unaggregated_fees = self.calculate_unaggregated_fee().await?;
@@ -691,7 +694,7 @@ impl SenderAllocationState {
         }
     }
 
-    pub async fn mark_rav_last(&self) -> Result<()> {
+    pub async fn mark_rav_last(&self) -> anyhow::Result<()> {
         tracing::info!(
             sender = %self.sender,
             allocation_id = %self.allocation_id,
@@ -731,7 +734,7 @@ impl SenderAllocationState {
     async fn store_invalid_receipts(
         &mut self,
         receipts: &[ReceiptWithState<Failed>],
-    ) -> Result<()> {
+    ) -> anyhow::Result<()> {
         let reciepts_len = receipts.len();
         let mut reciepts_signers = Vec::with_capacity(reciepts_len);
         let mut encoded_signatures = Vec::with_capacity(reciepts_len);
@@ -835,7 +838,7 @@ impl SenderAllocationState {
         expected_rav: &ReceiptAggregateVoucher,
         rav: &EIP712SignedMessage<ReceiptAggregateVoucher>,
         reason: &str,
-    ) -> Result<()> {
+    ) -> anyhow::Result<()> {
         sqlx::query!(
             r#"
                 INSERT INTO scalar_tap_rav_requests_failed (

crates/tap-agent/src/cli.rs

@@ -3,7 +3,6 @@
 
 use std::path::PathBuf;
 
-use anyhow::Result;
 use clap::Parser;
 use indexer_config::{Config as IndexerConfig, ConfigPrefix};
 use tracing::{
@@ -39,7 +38,7 @@ fn init_tracing(format: String) -> Result<(), SetGlobalDefaultError> {
     }
 }
 
-pub fn get_config() -> Result<IndexerConfig> {
+pub fn get_config() -> anyhow::Result<IndexerConfig> {
     let cli = Cli::parse();
     let config = IndexerConfig::parse(ConfigPrefix::Tap, cli.config.as_ref()).map_err(|e| {
         tracing::error!(

crates/tap-agent/src/main.rs

@@ -1,13 +1,12 @@
 // Copyright 2023-, Edge & Node, GraphOps, and Semiotic Labs.
 // SPDX-License-Identifier: Apache-2.0
 
-use anyhow::Result;
 use indexer_tap_agent::{agent, metrics, CONFIG};
 use ractor::ActorStatus;
 use tokio::signal::unix::{signal, SignalKind};
 
 #[tokio::main]
-async fn main() -> Result<()> {
+async fn main() -> anyhow::Result<()> {
     // Parse basic configurations, also initializes logging.
     lazy_static::initialize(&CONFIG);
 

crates/tap-agent/src/tap/context/receipt.rs

@@ -193,7 +193,6 @@ mod test {
     use std::collections::HashMap;
 
     use alloy::{primitives::U256, signers::local::PrivateKeySigner};
-    use anyhow::Result;
     use indexer_monitor::EscrowAccounts;
     use lazy_static::lazy_static;
     use sqlx::PgPool;
@@ -252,7 +251,7 @@ mod test {
         escrow_accounts: Receiver<EscrowAccounts>,
         received_receipt_vec: &[ReceiptWithState<Checking>],
         range: R,
-    ) -> Result<()> {
+    ) -> anyhow::Result<()> {
         let escrow_accounts_snapshot = escrow_accounts.borrow();
 
         // Filtering the received receipts by timestamp range
@@ -302,7 +301,7 @@ mod test {
         escrow_accounts: Receiver<EscrowAccounts>,
         received_receipt_vec: &[ReceiptWithState<Checking>],
         range: R,
-    ) -> Result<()> {
+    ) -> anyhow::Result<()> {
         let escrow_accounts_snapshot = escrow_accounts.borrow();
 
         // Storing the receipts

crates/tap-agent/src/test.rs

@@ -289,7 +289,7 @@ pub mod actors {
             &self,
             myself: ActorRef<Self::Msg>,
             state: &mut Self::State,
-        ) -> std::result::Result<(), ActorProcessingErr> {
+        ) -> Result<(), ActorProcessingErr> {
             self.inner.post_stop(myself, state).await
         }
 
@@ -298,7 +298,7 @@ pub mod actors {
             myself: ActorRef<Self::Msg>,
             msg: Self::Msg,
             state: &mut Self::State,
-        ) -> std::result::Result<(), ActorProcessingErr> {
+        ) -> Result<(), ActorProcessingErr> {
             let result = self.inner.handle(myself, msg, state).await;
             self.notify.notify_one();
             result
@@ -309,7 +309,7 @@ pub mod actors {
             myself: ActorRef<Self::Msg>,
             message: SupervisionEvent,
             state: &mut Self::State,
-        ) -> std::result::Result<(), ActorProcessingErr> {
+        ) -> Result<(), ActorProcessingErr> {
             self.inner
                 .handle_supervisor_evt(myself, message, state)
                 .await
@@ -467,7 +467,7 @@ pub mod actors {
             &self,
             _myself: ActorRef<Self::Msg>,
             _allocation_ids: Self::Arguments,
-        ) -> std::result::Result<Self::State, ActorProcessingErr> {
+        ) -> Result<Self::State, ActorProcessingErr> {
             Ok(())
         }
 
@@ -476,7 +476,7 @@ pub mod actors {
             _myself: ActorRef<Self::Msg>,
             message: Self::Msg,
             _state: &mut Self::State,
-        ) -> std::result::Result<(), ActorProcessingErr> {
+        ) -> Result<(), ActorProcessingErr> {
             self.last_message_emitted.send(message).await.unwrap();
             Ok(())
         }