bingle_cli 0.2.8

Command line interface for Bingle: register handles, run nodes/relays, and trade BINGLE on Algorand.
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

use bingle_core::api::bingle_api::StartOptions;
use bingle_core::blockchain::algo_ops::AlgoChainConfig;
use std::net::SocketAddr;

/// Describes the action to take on shutdown regarding static endpoint unregistration.
/// Mirrors the ShutdownAction enum in bingle_cli.rs for testability.
#[derive(Debug, PartialEq, Eq)]
enum ShutdownAction {
    NoStaticIp,
    NoAppId,
    NoPassphrase,
    Unregister {
        app_id: u64,
        passphrase: String,
        algo_provider_config: Option<AlgoChainConfig>,
        asset_id: Option<u64>,
    },
}

/// Mirrors resolve_shutdown_action from bingle_cli.rs.
/// The app_id_env parameter allows injecting the APP_ID environment variable for testability.
fn resolve_shutdown_action(opts: &StartOptions, app_id_env: Option<u64>) -> ShutdownAction {
    if opts.static_ip.is_none() {
        return ShutdownAction::NoStaticIp;
    }
    let app_id_opt = opts.app_id.or(app_id_env);
    match app_id_opt {
        None => ShutdownAction::NoAppId,
        Some(app_id) => match opts.algo_passphrase {
            Some(ref passphrase) => ShutdownAction::Unregister {
                app_id,
                passphrase: passphrase.clone(),
                algo_provider_config: opts.algo_provider_config.clone(),
                asset_id: opts.asset_id,
            },
            None => ShutdownAction::NoPassphrase,
        },
    }
}

fn make_opts_with_static_ip(addr: &str) -> StartOptions {
    let mut opts = StartOptions::new("".into());
    opts.static_ip = Some(addr.parse::<SocketAddr>().expect("valid socket addr"));
    opts
}

#[test]
#[cfg(not(target_os = "ios"))]
pub fn no_static_ip_returns_no_static_ip() {
    let opts = StartOptions::new("".into());
    let action = resolve_shutdown_action(&opts, None);
    assert_eq!(action, ShutdownAction::NoStaticIp);
}

#[test]
#[cfg(not(target_os = "ios"))]
pub fn static_ip_without_app_id_or_env_returns_no_app_id() {
    let opts = make_opts_with_static_ip("1.2.3.4:5000");
    let action = resolve_shutdown_action(&opts, None);
    assert_eq!(action, ShutdownAction::NoAppId);
}

#[test]
#[cfg(not(target_os = "ios"))]
pub fn static_ip_with_app_id_but_no_passphrase_returns_no_passphrase() {
    let mut opts = make_opts_with_static_ip("1.2.3.4:5000");
    opts.app_id = Some(12345);
    let action = resolve_shutdown_action(&opts, None);
    assert_eq!(action, ShutdownAction::NoPassphrase);
}

#[test]
#[cfg(not(target_os = "ios"))]
pub fn static_ip_with_env_app_id_but_no_passphrase_returns_no_passphrase() {
    let opts = make_opts_with_static_ip("1.2.3.4:5000");
    let action = resolve_shutdown_action(&opts, Some(99999));
    assert_eq!(action, ShutdownAction::NoPassphrase);
}

#[test]
#[cfg(not(target_os = "ios"))]
pub fn static_ip_with_app_id_and_passphrase_returns_unregister() {
    let mut opts = make_opts_with_static_ip("44.223.62.108:12121");
    opts.app_id = Some(757297220);
    opts.algo_passphrase = Some("test passphrase".to_string());
    let action = resolve_shutdown_action(&opts, None);
    assert_eq!(
        action,
        ShutdownAction::Unregister {
            app_id: 757297220,
            passphrase: "test passphrase".to_string(),
            algo_provider_config: None,
            asset_id: None,
        }
    );
}

#[test]
#[cfg(not(target_os = "ios"))]
pub fn env_app_id_used_when_opts_app_id_is_none() {
    let mut opts = make_opts_with_static_ip("10.0.0.1:8080");
    opts.algo_passphrase = Some("my secret".to_string());
    // opts.app_id is None, but env provides it
    let action = resolve_shutdown_action(&opts, Some(42));
    assert_eq!(
        action,
        ShutdownAction::Unregister {
            app_id: 42,
            passphrase: "my secret".to_string(),
            algo_provider_config: None,
            asset_id: None,
        }
    );
}

#[test]
#[cfg(not(target_os = "ios"))]
pub fn opts_app_id_takes_precedence_over_env() {
    let mut opts = make_opts_with_static_ip("10.0.0.1:8080");
    opts.app_id = Some(100);
    opts.algo_passphrase = Some("pw".to_string());
    let action = resolve_shutdown_action(&opts, Some(999));
    assert_eq!(
        action,
        ShutdownAction::Unregister {
            app_id: 100,
            passphrase: "pw".to_string(),
            algo_provider_config: None,
            asset_id: None,
        }
    );
}

#[test]
#[cfg(not(target_os = "ios"))]
pub fn unregister_includes_provider_config_and_asset_id() {
    let mut opts = make_opts_with_static_ip("10.0.0.1:8080");
    opts.app_id = Some(100);
    opts.asset_id = Some(200);
    opts.algo_passphrase = Some("pw".to_string());
    let config = AlgoChainConfig {
        client_api_url: "https://example.com".to_string(),
        client_api_port: 443,
        indexer_api_url: "https://idx.example.com".to_string(),
        indexer_api_port: 443,
        token: Some("tok".to_string()),
        token_key: None,
        app_id: Some(100),
        asset_id: Some(200),
    };
    opts.algo_provider_config = Some(config.clone());
    let action = resolve_shutdown_action(&opts, None);
    assert_eq!(
        action,
        ShutdownAction::Unregister {
            app_id: 100,
            passphrase: "pw".to_string(),
            algo_provider_config: Some(config),
            asset_id: Some(200),
        }
    );
}