rusplay 0.1.6

Memory safe, blazing fast Rugplay library written in Rust
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

#![deny(clippy::all)]
mod common;
use std::time::Duration;

use common::test_client;
use rusplay::models::CoinTradeType;

#[tokio::test]
#[ignore]
async fn test_get_top_coins_live() {
    let client = test_client().expect("Missing credentials: RUGPLAY_COOKIE or RUGPLAY_TOKEN");
    let result = client.get_top_coins().await;
    assert!(result.is_ok(), "API call failed: {:#?}", result);
    let response = result.unwrap();
    assert!(!response.coins.is_empty(), "Expected non-empty coin list");
    println!("First coin: {:?}", response.coins[0]);
}

#[tokio::test]
#[ignore]
async fn test_get_market_live() {
    let client = test_client().expect("Missing credentials: RUGPLAY_COOKIE or RUGPLAY_TOKEN");
    let params = &[
        ("limit", "5"),
        ("sortBy", "marketCap"),
        ("sortOrder", "desc"),
    ];
    let result = client.get_market(params).await;
    assert!(result.is_ok(), "API call failed: {:?}", result);
    let response = result.unwrap();
    assert!(!response.coins.is_empty(), "Expected non-empty market data");
    println!("Market response sample: {:?}", response.coins.first());
}

#[tokio::test]
#[ignore]
async fn test_get_coin_details_live() {
    let client = test_client().expect("Missing credentials: RUGPLAY_COOKIE or RUGPLAY_TOKEN");
    let result = client.get_coin_details("BTC", Some("1h")).await;
    assert!(result.is_ok(), "API call failed: {:?}", result);
    let response = result.unwrap();
    assert_eq!(response.coin.symbol, "BTC", "Expected BTC coin details");
    println!("Coin details: {:?}", response);
}

#[tokio::test]
#[ignore]
async fn test_get_holders_live() {
    let client = test_client().expect("Missing credentials: RUGPLAY_COOKIE or RUGPLAY_TOKEN");
    let result = client.get_holders("BTC", Some(10)).await;
    assert!(result.is_ok(), "API call failed: {:?}", result);
    let response = result.unwrap();
    assert!(
        !response.holders.is_empty(),
        "Expected non-empty holder list"
    );
    println!("Top holder: {:?}", response.holders.first());
}

#[tokio::test]
#[ignore]
async fn test_get_hopium_live() {
    use rusplay::models::HopiumFilter;
    let client = test_client().expect("Missing credentials: RUGPLAY_COOKIE or RUGPLAY_TOKEN");
    let result = client.get_hopium(HopiumFilter::ALL, Some(5), Some(1)).await;
    assert!(result.is_ok(), "API call failed: {:?}", result);
    let response = result.unwrap();
    assert!(
        !response.questions.is_empty(),
        "Expected non-empty hopium questions"
    );
    println!("First hopium question: {:?}", response.questions.first());
}

#[tokio::test]
#[ignore]
async fn test_get_hopium_details_live() {
    let client = test_client().expect("Missing credentials: RUGPLAY_COOKIE or RUGPLAY_TOKEN");
    // Pick a known question ID or get from `get_hopium`
    let question_id = 1;
    let result = client.get_hopium_details(question_id).await;
    assert!(result.is_ok(), "API call failed: {:?}", result);
    let response = result.unwrap();
    assert_eq!(
        response.question.id as u32, question_id,
        "Expected matching hopium question ID"
    );
    println!("Hopium question details: {:?}", response);
}

#[tokio::test]
#[ignore]
async fn test_get_claim_info_live() {
    let client = test_client().expect("Missing credentials: RUGPLAY_COOKIE or RUGPLAY_TOKEN");
    let result = client.get_claim_info().await;
    assert!(result.is_ok(), "API call failed: {:?}", result);
    let response = result.unwrap();
    println!("Claim info: {:?}", response);
}

#[tokio::test]
#[ignore]
async fn test_claim_reward_live() {
    let client = test_client().expect("Missing credentials: RUGPLAY_COOKIE or RUGPLAY_TOKEN");
    let result = client.claim_reward().await;
    assert!(result.is_ok(), "API call failed: {:?}", result);
    let response = result.unwrap();
    println!("Claim reward response: {:?}", response);
}

#[tokio::test]
#[ignore]
async fn test_trade_live() {
    let client = test_client().expect("Missing credentials: RUGPLAY_COOKIE or RUGPLAY_TOKEN");
    let buy = client.trade("BTC", CoinTradeType::BUY, 1).await;
    assert!(buy.is_ok(), "API call failed: {:?}", buy);
    let buy_response = buy.unwrap();
    println!("Buy response: {:?}", buy_response);

    std::thread::sleep(Duration::from_secs(1));

    let sell = client.trade("BTC", CoinTradeType::SELL, 1).await;
    assert!(sell.is_ok(), "API call failed: {:?}", sell);
    let sell_response = sell.unwrap();
    println!("Claim reward response: {:?}", sell_response);
}

#[tokio::test]
#[ignore]
async fn test_recent_trades_live() {
    let client = test_client().expect("Missing credentials: RUGPLAY_COOKIE or RUGPLAY_TOKEN");

    let result = client.get_recent_trades(100).await;

    assert!(result.is_ok(), "API call failed: {:?}", result);
    let response = result.unwrap();
    println!(
        "Got {} trades. First trade: {:?}",
        response.trades.len(),
        response.trades.get(0).unwrap()
    );
}