zinc-wallet-cli 0.4.0

Agent-first Bitcoin + Ordinals CLI wallet with account-based taproot ordinals + native segwit payment addresses (optional human mode)
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use crate::cli::{Cli, ScenarioAction, ScenarioArgs};
use crate::error::AppError;
use crate::output::CommandOutput;
use crate::utils::run_bitcoin_cli;
use crate::wallet_service::NetworkArg;
use crate::{confirm, load_wallet_session, persist_wallet_session, snapshot_dir};
use std::fs;

pub async fn run(cli: &Cli, args: &ScenarioArgs) -> Result<CommandOutput, AppError> {
    let mut session = load_wallet_session(cli)?;
    if !matches!(session.profile.network, NetworkArg::Regtest) {
        return Err(AppError::Invalid(
            "scenario commands are only supported on regtest profiles".to_string(),
        ));
    }

    let mut should_persist = true;
    let result = match &args.action {
        ScenarioAction::Mine { blocks, address } => {
            if *blocks == 0 {
                return Err(AppError::Invalid(
                    "--blocks must be greater than 0".to_string(),
                ));
            }

            let mining_address = if let Some(address) = address {
                address.clone()
            } else {
                session.wallet.peek_taproot_address(0).to_string()
            };

            let generated = run_bitcoin_cli(
                &session.profile,
                &[
                    "generatetoaddress".to_string(),
                    blocks.to_string(),
                    mining_address.clone(),
                ],
            )?;

            CommandOutput::ScenarioMine {
                blocks: u64::from(*blocks),
                address: mining_address,
                raw_output: generated,
            }
        }
        ScenarioAction::Fund {
            address,
            amount_btc,
            mine_blocks,
        } => {
            if *mine_blocks == 0 {
                return Err(AppError::Invalid(
                    "--mine-blocks must be greater than 0".to_string(),
                ));
            }
            let destination = if let Some(address) = address {
                address.clone()
            } else {
                session.wallet.peek_taproot_address(0).to_string()
            };

            let txid = run_bitcoin_cli(
                &session.profile,
                &[
                    "sendtoaddress".to_string(),
                    destination.clone(),
                    amount_btc.clone(),
                ],
            )?;

            let mine_address = session.wallet.peek_taproot_address(0).to_string();
            let generated = run_bitcoin_cli(
                &session.profile,
                &[
                    "generatetoaddress".to_string(),
                    mine_blocks.to_string(),
                    mine_address.clone(),
                ],
            )?;

            CommandOutput::ScenarioFund {
                address: destination,
                amount_btc: amount_btc.clone(),
                txid: txid.trim().to_string(),
                mine_blocks: u64::from(*mine_blocks),
                mine_address,
                generated_blocks: generated,
            }
        }
        ScenarioAction::Reset {
            remove_profile,
            remove_snapshots,
        } => {
            if !confirm("Are you sure you want to reset the scenario? This may delete your profile and/or snapshots.", cli) {
                return Err(AppError::Internal("aborted by user".to_string()));
            }
            should_persist = false;
            let mut removed = Vec::new();
            if (*remove_profile || (!remove_profile && !remove_snapshots))
                && session.profile_path.exists()
            {
                fs::remove_file(&session.profile_path).map_err(|e| {
                    AppError::Config(format!(
                        "failed to remove profile {}: {e}",
                        session.profile_path.display()
                    ))
                })?;
                removed.push(session.profile_path.display().to_string());
            }
            if *remove_snapshots || (!remove_profile && !remove_snapshots) {
                let snap_dir = snapshot_dir(cli)?;
                if snap_dir.exists() {
                    fs::remove_dir_all(&snap_dir).map_err(|e| {
                        AppError::Config(format!(
                            "failed to remove snapshots {}: {e}",
                            snap_dir.display()
                        ))
                    })?;
                    removed.push(snap_dir.display().to_string());
                }
            }

            CommandOutput::ScenarioReset { removed }
        }
    };

    if should_persist {
        persist_wallet_session(&mut session)?;
    }
    Ok(result)
}