outlayer-cli 0.1.1

CLI for deploying, running, and managing OutLayer agents
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

use anyhow::Result;
use serde_json::json;

use crate::api::ApiClient;
use crate::config::{self, NetworkConfig};
use crate::near::{ContractCaller, NearClient};

/// `outlayer earnings` — show developer earnings
pub async fn show(network: &NetworkConfig) -> Result<()> {
    let creds = config::load_credentials(network)?;
    let api = ApiClient::new(network);
    let near = NearClient::new(network);

    // Get HTTPS earnings from coordinator
    let https_earnings = api
        .get_project_owner_earnings(&creds.account_id)
        .await
        .ok();

    // Get blockchain earnings from contract
    let blockchain_earnings = near.get_developer_earnings(&creds.account_id).await.ok();

    let https_balance = https_earnings
        .as_ref()
        .map(|e| format_usd(&e.balance))
        .unwrap_or_else(|| "$0.00".to_string());

    let https_total = https_earnings
        .as_ref()
        .map(|e| format_usd(&e.total_earned))
        .unwrap_or_else(|| "$0.00".to_string());

    let blockchain_balance = blockchain_earnings
        .as_ref()
        .map(|e| format_usd(e))
        .unwrap_or_else(|| "$0.00".to_string());

    println!("Blockchain earnings:  {blockchain_balance}");
    println!("HTTPS API earnings:   {https_balance} (total: {https_total})");

    Ok(())
}

/// `outlayer earnings withdraw` — withdraw blockchain earnings
pub async fn withdraw(network: &NetworkConfig) -> Result<()> {
    let creds = config::load_credentials(network)?;

    let caller = ContractCaller::from_credentials(&creds, network)?;
    let gas = 100_000_000_000_000u64; // 100 TGas

    caller
        .call_contract("withdraw_developer_earnings", json!({}), gas, 1) // 1 yoctoNEAR
        .await?;

    eprintln!("Earnings withdrawn to {}", creds.account_id);
    Ok(())
}

/// `outlayer earnings history` — view earnings history
pub async fn history(
    network: &NetworkConfig,
    source: Option<String>,
    limit: i64,
) -> Result<()> {
    let creds = config::load_credentials(network)?;
    let api = ApiClient::new(network);

    let resp = api
        .get_earnings_history(&creds.account_id, source.as_deref(), limit, 0)
        .await?;

    if resp.earnings.is_empty() {
        eprintln!("No earnings history.");
        return Ok(());
    }

    println!(
        "{:<12} {:<10} {:<25} {:>10}",
        "DATE", "SOURCE", "PROJECT", "AMOUNT"
    );

    for e in &resp.earnings {
        let date = format_timestamp(e.created_at);
        let amount = format_usd(&e.amount);
        println!(
            "{:<12} {:<10} {:<25} {:>10}",
            date, e.source, e.project_id, amount
        );
    }

    if resp.total_count > limit {
        eprintln!(
            "\nShowing {}/{} entries. Use --limit to see more.",
            resp.earnings.len(),
            resp.total_count
        );
    }

    Ok(())
}

/// Format minimal USD units (6 decimals) to human-readable
fn format_usd(minimal_units: &str) -> String {
    let units: u64 = minimal_units.parse().unwrap_or(0);
    let dollars = units as f64 / 1_000_000.0;
    format!("${:.2}", dollars)
}

fn format_timestamp(ts: i64) -> String {
    // ts is unix seconds or milliseconds — normalize
    let secs = if ts > 1_000_000_000_000 {
        ts / 1000
    } else {
        ts
    };
    // Simple date format without chrono
    let days_since_epoch = secs / 86400;
    // Approximate: good enough for display
    let year = 1970 + (days_since_epoch / 365);
    let day_in_year = days_since_epoch % 365;
    let month = day_in_year / 30 + 1;
    let day = day_in_year % 30 + 1;
    format!("{:04}-{:02}-{:02}", year, month, day)
}