teasel 0.14.0

Lightweight CLI utilities for inspecting Miden files, local stores, and RPC endpoints
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use anyhow::Result;
use miden_client::{
    account::AccountId,
    address::NetworkId,
    rpc::{Endpoint, GrpcClient, NodeRpcClient},
};
use tokio::runtime::Runtime;

use crate::render::account::render_account;
use crate::util::net::DEFAULT_TIMEOUT_MS;

/// Fetch and display account details for an on-chain account id or bech32 address.
pub(crate) fn inspect_account(
    account_id: AccountId,
    address_network_hint: Option<NetworkId>,
    selected_network_id: Option<NetworkId>,
    verbose: bool,
    endpoint: Endpoint,
) -> Result<()> {
    let rt = Runtime::new()?;

    rt.block_on(async move {
        let rpc = GrpcClient::new(&endpoint, DEFAULT_TIMEOUT_MS);
        match rpc.get_account_details(account_id).await {
            Ok(fetched) => {
                println!("Account {account_id}:");
                if let Some(address_network) = address_network_hint {
                    if let Some(expected) = selected_network_id {
                        if expected != address_network {
                            println!(
                                "- warning: address network {address_network} does not match selected {expected}"
                            );
                        } else {
                            println!("- address network: {address_network}");
                        }
                    } else {
                        println!("- address network: {address_network}");
                    }
                }
                println!("- commitment: {}", fetched.commitment());

                match fetched {
                    miden_client::rpc::domain::account::FetchedAccount::Private(_, summary) => {
                        println!("- latest block: {}", summary.last_block_num);
                        if verbose {
                            println!("- type: private (state not available)");
                        } else {
                            println!("- header unavailable (private account)");
                        }
                    },
                    miden_client::rpc::domain::account::FetchedAccount::Public(account, summary) => {
                        println!("- latest block: {}", summary.last_block_num);
                        render_account(account.as_ref(), verbose);
                    },
                }
            },
            Err(err) => {
                println!("Failed to fetch account {account_id}: {err}");
            },
        }
        Ok(())
    })
}