hylix 0.10.1

Build, test & deploy verifiable apps on Hyli
Documentation 
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

use crate::commands::devnet::DevnetContext;
use crate::config::{AccountConfig, FundConfig};
use crate::error::{HylixError, HylixResult};
use crate::logging::{log_info, log_success, log_warning, ProgressExecutor};
use client_sdk::rest_client::NodeApiClient;
use std::time::Duration;

/// Execute the `hy bake` command
pub async fn bake_devnet(executor: &ProgressExecutor, context: &DevnetContext) -> HylixResult<()> {
    // Create default profile if it doesn't exist
    context.config.create_default_profile()?;

    // Determine which profile to use: CLI argument, context profile, or default
    let profile_name = context
        .profile
        .as_ref()
        .unwrap_or(&context.config.bake_profile);

    // Load the profile
    let profile = context.config.load_bake_profile(profile_name)?;

    // Check if devnet is running
    if !is_devnet_running(context).await? {
        return Err(HylixError::devnet(
            "Devnet is not running. Please start the devnet first with 'hy devnet start'."
                .to_string(),
        ));
    }

    // Create pre-funded test accounts
    create_test_accounts(executor, context, &profile.accounts).await?;
    log_success("[1/2] Test accounts created");

    // Send funds to test accounts
    send_funds_to_test_accounts(executor, context, &profile.funds).await?;
    log_success("[2/2] Funds sent to test accounts");

    log_success("Bake process completed successfully!");
    log_info(&format!("Using profile: {}", profile.name));
    log_info("Test accounts created:");
    for account in &profile.accounts {
        log_info(&format!(
            "  - {} (password: {})",
            account.name, account.password
        ));
    }
    log_info("Test accounts funded:");
    for fund in &profile.funds {
        log_info(&format!(
            "  - {} -> {} ({} {})",
            fund.from, fund.to, fund.amount, fund.token
        ));
    }

    Ok(())
}

/// Check if devnet is running
async fn is_devnet_running(context: &DevnetContext) -> HylixResult<bool> {
    // Use tokio::time::timeout to add a timeout to the async call
    match tokio::time::timeout(Duration::from_secs(5), context.client.get_block_height()).await {
        Ok(result) => match result {
            Ok(_) => Ok(true),
            Err(_) => Ok(false),
        },
        Err(_) => Ok(false),
    }
}

/// Create pre-funded test accounts
pub async fn create_test_accounts(
    executor: &ProgressExecutor,
    _context: &DevnetContext,
    accounts: &[AccountConfig],
) -> HylixResult<()> {
    let main_pb = executor.add_task("Creating test accounts...");

    for account in accounts {
        main_pb.set_message(format!("Creating test account: {}...", account.name));
        let task_name = format!("Creating account {}", account.name);
        let success = executor
            .execute_command(
                task_name,
                "npx",
                &[
                    "--yes",
                    "hyli-wallet-cli",
                    "register",
                    &account.name,
                    &account.password,
                    &account.invite_code,
                ],
                None,
            )
            .await?;

        if !success {
            log_warning(&format!(
                "{} account creation completed with warnings",
                account.name
            ));
        } else {
            main_pb.set_message(format!("{} account created successfully", account.name));
        }
    }

    main_pb.finish_and_clear();

    Ok(())
}

/// Send funds to test accounts
pub async fn send_funds_to_test_accounts(
    executor: &ProgressExecutor,
    _context: &DevnetContext,
    funds: &[FundConfig],
) -> HylixResult<()> {
    let pb = executor.add_task("Sending funds to test accounts...");

    for fund in funds {
        pb.set_message(format!(
            "{} sending {} {} to {}...",
            fund.from, fund.amount, fund.token, fund.to
        ));

        let destination = format!("{}@wallet", fund.to);
        let amount_str = fund.amount.to_string();

        let task_name = format!("Funding account {}", fund.to);
        let success = executor
            .execute_command(
                task_name,
                "npx",
                &[
                    "hyli-wallet-cli",
                    "transfer",
                    &fund.from,
                    &fund.from_password,
                    &amount_str,
                    &fund.token,
                    &destination,
                ],
                None,
            )
            .await?;

        if !success {
            log_warning(&format!(
                "{} account funding completed with warnings",
                fund.to
            ));
            log_warning(&format!(
                "Command was: {}",
                console::style(format!(
                    "npx hyli-wallet-cli transfer {} {} {} {} {}",
                    fund.from, fund.from_password, amount_str, fund.token, destination
                ))
                .green()
            ));
        } else {
            pb.set_message(format!("{} account funded successfully", fund.to));
        }
    }

    pb.finish_and_clear();

    Ok(())
}