[cli] improve ux and info on vouch and cw reauth txs (#411)

Co-authored-by: Montague di Hart <[email protected]>
Co-authored-by: Vale Fitz Piano <[email protected]>
Co-authored-by: Gianna McDiminuendo <[email protected]>
Co-authored-by: Isa di Hind <[email protected]>
Co-authored-by: Peregrine Saint Hart <[email protected]>
Co-authored-by: Peregrine Saint Forte <[email protected]>
Co-authored-by: Reginald Andante <[email protected]>
Co-authored-by: Peregrine Von Urchin <[email protected]>
Co-authored-by: Gianna Accelerando <[email protected]>
Co-authored-by: Cholmondeley Hobby <[email protected]>
Co-authored-by: Franci Leveret <[email protected]>
Co-authored-by: 0o-de-lally <[email protected]>

Author: 13 people

Cargo.lock

@@ -183,9 +183,11 @@ module ol_framework::vouch_limits {
     #[view]
     /// Calculate the maximum number of vouches a user should be able to give based on their trust score
     public fun calculate_score_limit(grantor_acc: address): u64 {
-        // Calculate the quality using the social distance method
+        // Get the user's vouching limit using the social distance method
         // This avoids dependency on page_rank_lazy
-        let trust_score = page_rank_lazy::get_trust_score(grantor_acc);
+
+        // commit note: this was previously an impure function which would fail
+        let trust_score = page_rank_lazy::get_cached_score(grantor_acc);
         let max_score = page_rank_lazy::get_max_single_score();
 
         // For accounts with low quality vouchers,

framework/libra-framework/sources/ol_sources/vouch_lib/vouch_limits.move

@@ -19,6 +19,7 @@ diem-debugger = { workspace = true }
 diem-sdk = { workspace = true }
 indoc = { workspace = true }
 libra-types = { workspace = true }
+serde = { workspace = true }
 serde_json = { workspace = true }
 tokio = { workspace = true }
 url = { workspace = true }

tools/query/Cargo.toml

@@ -11,8 +11,22 @@ use libra_types::{
     move_resource::{gas_coin::SlowWalletBalance, txschedule::TxSchedule},
     type_extensions::client_ext::{entry_function_id, ClientExt},
 };
+use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 
+/// Structured data for account vouch report
+#[derive(Debug, Serialize, Deserialize)]
+pub struct AccountVouchReportData {
+    pub account: String,
+    pub cached_score: Option<u64>,
+    pub fresh_score: Option<u64>,
+    pub max_depth_reached: Option<u64>,
+    pub accounts_processed: Option<u64>,
+    pub max_vouches_by_score: Option<u64>,
+    pub remaining_vouches_available: Option<u64>,
+    pub errors: Vec<String>,
+}
+
 /// helper to get libra balance at a SlowWalletBalance type which shows
 /// total balance and the unlocked balance.
 pub async fn get_account_balance_libra(
@@ -134,3 +148,271 @@ pub async fn multi_auth_ballots(
 
     Ok(r.data)
 }
+
+/// Calculates a fresh page rank trust score for an account without updating the cache.
+/// Returns (score, max_depth_reached, accounts_processed) as a tuple.
+pub async fn page_rank_calculate_score(
+    client: &Client,
+    account: AccountAddress,
+) -> anyhow::Result<(u64, u64, u64)> {
+    let calculate_score_id = entry_function_id("page_rank_lazy", "calculate_score")?;
+    let request = ViewRequest {
+        function: calculate_score_id,
+        type_arguments: vec![],
+        arguments: vec![account.to_string().into()],
+    };
+
+    let res = client.view(&request, None).await?.into_inner();
+
+    // Parse the tuple response (score, max_depth_reached, accounts_processed)
+    if res.len() != 3 {
+        return Err(anyhow::anyhow!(
+            "Expected 3 values from calculate_score, got {}",
+            res.len()
+        ));
+    }
+
+    // Handle string or numeric responses from the Move VM
+    let score: u64 = match &res[0] {
+        serde_json::Value::String(s) => s.parse()?,
+        serde_json::Value::Number(n) => n
+            .as_u64()
+            .ok_or_else(|| anyhow::anyhow!("Invalid number format for score"))?,
+        _ => return Err(anyhow::anyhow!("Unexpected response type for score")),
+    };
+
+    let max_depth_reached: u64 = match &res[1] {
+        serde_json::Value::String(s) => s.parse()?,
+        serde_json::Value::Number(n) => n
+            .as_u64()
+            .ok_or_else(|| anyhow::anyhow!("Invalid number format for max_depth"))?,
+        _ => return Err(anyhow::anyhow!("Unexpected response type for max_depth")),
+    };
+
+    let accounts_processed: u64 = match &res[2] {
+        serde_json::Value::String(s) => s.parse()?,
+        serde_json::Value::Number(n) => n
+            .as_u64()
+            .ok_or_else(|| anyhow::anyhow!("Invalid number format for accounts_processed"))?,
+        _ => {
+            return Err(anyhow::anyhow!(
+                "Unexpected response type for accounts_processed"
+            ))
+        }
+    };
+
+    Ok((score, max_depth_reached, accounts_processed))
+}
+
+/// Retrieves the cached page rank trust score for an account.
+/// This returns the previously computed score without recalculation.
+pub async fn page_rank_get_cached_score(
+    client: &Client,
+    account: AccountAddress,
+) -> anyhow::Result<u64> {
+    let get_cached_score_id = entry_function_id("page_rank_lazy", "get_cached_score")?;
+    let request = ViewRequest {
+        function: get_cached_score_id,
+        type_arguments: vec![],
+        arguments: vec![account.to_string().into()],
+    };
+
+    let res = client.view(&request, None).await?.into_inner();
+
+    // Parse the single u64 response
+    if res.is_empty() {
+        return Err(anyhow::anyhow!("No values returned from get_cached_score"));
+    }
+
+    // Handle both string and numeric responses from the Move VM
+    let score: u64 = match &res[0] {
+        serde_json::Value::String(s) => s.parse()?,
+        serde_json::Value::Number(n) => n
+            .as_u64()
+            .ok_or_else(|| anyhow::anyhow!("Invalid number format"))?,
+        _ => return Err(anyhow::anyhow!("Unexpected response type for cached score")),
+    };
+    Ok(score)
+}
+
+/// Calculates the maximum number of vouches a user should be able to give based on their trust score.
+/// This is determined by the user's page rank trust score relative to the maximum score in the system.
+pub async fn vouch_limits_calculate_score_limit(
+    client: &Client,
+    account: AccountAddress,
+) -> anyhow::Result<u64> {
+    let calculate_score_limit_id = entry_function_id("vouch_limits", "calculate_score_limit")?;
+    let request = ViewRequest {
+        function: calculate_score_limit_id,
+        type_arguments: vec![],
+        arguments: vec![account.to_string().into()],
+    };
+
+    let res = client.view(&request, None).await?.into_inner();
+
+    // Parse the single u64 response
+    if res.is_empty() {
+        return Err(anyhow::anyhow!(
+            "No values returned from calculate_score_limit"
+        ));
+    }
+
+    // Handle both string and numeric responses from the Move VM
+    let limit: u64 = match &res[0] {
+        serde_json::Value::String(s) => s.parse()?,
+        serde_json::Value::Number(n) => n
+            .as_u64()
+            .ok_or_else(|| anyhow::anyhow!("Invalid number format"))?,
+        _ => return Err(anyhow::anyhow!("Unexpected response type for score limit")),
+    };
+    Ok(limit)
+}
+
+/// Returns the number of vouches a user can still give based on system limits.
+/// This takes into account all constraints: base maximum limit, score-based limit,
+/// received vouches + 1 limit, and per-epoch limit.
+pub async fn vouch_limits_get_vouch_limit(
+    client: &Client,
+    account: AccountAddress,
+) -> anyhow::Result<u64> {
+    let get_vouch_limit_id = entry_function_id("vouch_limits", "get_vouch_limit")?;
+    let request = ViewRequest {
+        function: get_vouch_limit_id,
+        type_arguments: vec![],
+        arguments: vec![account.to_string().into()],
+    };
+
+    let res = client.view(&request, None).await?.into_inner();
+
+    // Parse the single u64 response
+    if res.is_empty() {
+        return Err(anyhow::anyhow!("No values returned from get_vouch_limit"));
+    }
+
+    // Handle both string and numeric responses from the Move VM
+    let limit: u64 = match &res[0] {
+        serde_json::Value::String(s) => s.parse()?,
+        serde_json::Value::Number(n) => n
+            .as_u64()
+            .ok_or_else(|| anyhow::anyhow!("Invalid number format"))?,
+        _ => return Err(anyhow::anyhow!("Unexpected response type for vouch limit")),
+    };
+    Ok(limit)
+}
+
+/// Creates a comprehensive vouch report for an account, combining page rank scores and vouch limits.
+/// This function returns structured data that can be used for JSON output or further processing.
+pub async fn account_vouch_report(
+    client: &Client,
+    account: AccountAddress,
+) -> anyhow::Result<AccountVouchReportData> {
+    let mut errors = Vec::new();
+
+    // Get page rank scores
+    let cached_score = match page_rank_get_cached_score(client, account).await {
+        Ok(score) => Some(score),
+        Err(e) => {
+            errors.push(format!("cached_score: {}", e));
+            None
+        }
+    };
+
+    let (fresh_score, max_depth_reached, accounts_processed) =
+        match page_rank_calculate_score(client, account).await {
+            Ok((score, max_depth_reached, accounts_processed)) => (
+                Some(score),
+                Some(max_depth_reached),
+                Some(accounts_processed),
+            ),
+            Err(e) => {
+                errors.push(format!("fresh_score: {}", e));
+                (None, None, None)
+            }
+        };
+
+    // Get vouch limits
+    let max_vouches_by_score = match vouch_limits_calculate_score_limit(client, account).await {
+        Ok(limit) => Some(limit),
+        Err(e) => {
+            errors.push(format!("max_vouches_by_score: {}", e));
+            None
+        }
+    };
+
+    let remaining_vouches_available = match vouch_limits_get_vouch_limit(client, account).await {
+        Ok(limit) => Some(limit),
+        Err(e) => {
+            errors.push(format!("remaining_vouches_available: {}", e));
+            None
+        }
+    };
+
+    Ok(AccountVouchReportData {
+        account: account.to_string(),
+        cached_score,
+        fresh_score,
+        max_depth_reached,
+        accounts_processed,
+        max_vouches_by_score,
+        remaining_vouches_available,
+        errors,
+    })
+}
+
+/// Prints a comprehensive vouch report for an account to the console.
+/// This function provides a readable summary of an account's trust metrics and vouching capabilities.
+pub async fn account_vouch_report_console(
+    client: &Client,
+    account: AccountAddress,
+) -> anyhow::Result<()> {
+    let report = account_vouch_report(client, account).await?;
+
+    println!("=== Account Vouch Report for {} ===\n", account);
+
+    // Page rank scores
+    println!("Page Rank Trust Scores:");
+
+    match report.cached_score {
+        Some(score) => println!("  • Cached Trust Score: {}", score),
+        None => println!("  • Cached Trust Score: Not available"),
+    }
+
+    match (
+        report.fresh_score,
+        report.max_depth_reached,
+        report.accounts_processed,
+    ) {
+        (Some(score), Some(max_depth), Some(accounts_processed)) => {
+            println!("  • Fresh Trust Score: {}", score);
+            println!("  • Max Depth Reached: {}", max_depth);
+            println!("  • Accounts Processed: {}", accounts_processed);
+        }
+        _ => println!("  • Fresh Trust Score: Not available"),
+    }
+
+    println!();
+
+    // Vouch limits
+    println!("Vouching Limits:");
+
+    match report.max_vouches_by_score {
+        Some(limit) => println!("  • Max Vouches (based on trust score): {}", limit),
+        None => println!("  • Max Vouches (based on trust score): Not available"),
+    }
+
+    match report.remaining_vouches_available {
+        Some(limit) => println!("  • Remaining Vouches Available: {}", limit),
+        None => println!("  • Remaining Vouches Available: Not available"),
+    }
+
+    // Show errors if any
+    if !report.errors.is_empty() {
+        println!("\nErrors encountered:");
+        for error in &report.errors {
+            println!("  • {}", error);
+        }
+    }
+
+    println!("\n=== End of Report ===");
+    Ok(())
+}

tools/query/src/account_queries.rs

@@ -1,6 +1,6 @@
 use crate::{
     account_queries::{
-        community_wallet_scheduled_transactions, community_wallet_signers,
+        account_vouch_report, community_wallet_scheduled_transactions, community_wallet_signers,
         get_account_balance_libra, get_events, get_transactions, get_val_config,
         is_community_wallet_migrated,
     },
@@ -125,6 +125,11 @@ pub enum QueryType {
     },
     /// Display all account structs
     Annotate { account: AccountAddress },
+    /// Generate a comprehensive vouch report showing page rank scores and vouch limits
+    VouchReport {
+        /// account to generate vouch report for
+        account: AccountAddress,
+    },
 }
 
 impl QueryType {
@@ -247,6 +252,12 @@ impl QueryType {
                 let pretty = format!("{:#}", blob.unwrap().to_string());
                 Ok(json!(pretty))
             }
+            QueryType::VouchReport { account } => {
+                // Get the structured vouch report data
+                let report_data = account_vouch_report(client, *account).await?;
+                // Return the data as JSON
+                Ok(json!(report_data))
+            }
             _ => {
                 bail!(
                     "Not implemented for type: {:?}\n Ground control to Major Tom.",

tools/query/src/query_type.rs

@@ -486,7 +486,7 @@ impl ReauthVoteTx {
     pub async fn run(&self, sender: &mut Sender) -> anyhow::Result<()> {
         // Submit the reauthorization vote
         let payload = libra_stdlib::donor_voice_txs_vote_reauth_tx(self.community_wallet);
-        sender.sign_submit_wait(payload).await.ok();
+        sender.sign_submit_wait(payload).await?;
 
         // First, check if we have pending reauthorization ballots
         let ballot_id =