hyperliquid 0.2.4

A Rust library for the Hyperliquid API
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

use std::sync::Arc;

use ethers::signers::LocalWallet;
use hyperliquid::{
    types::{
        exchange::response::{Response, StatusType},
        Chain,
    },
    Exchange, Hyperliquid,
};

#[tokio::main]
async fn main() {
    // Key was randomly generated for testing and shouldn't be used with any real funds
    let wallet: Arc<LocalWallet> = Arc::new(
        "e908f86dbb4d55ac876378565aafeabc187f6690f046459397b17d9b9a19688e"
            .parse()
            .unwrap(),
    );

    let exchange: Exchange = Hyperliquid::new(Chain::ArbitrumTestnet);

    println!("Creating subaccount...");
    let name = {
        let suffix = timestamp().to_string();

        // slice the last 4 characters
        let suffix = &suffix[suffix.len() - 4..];

        format!("Acc-{}", suffix)
    };

    let response = exchange
        .create_sub_account(wallet.clone(), name.clone())
        .await
        .expect("Failed to create subaccount");

    let response = match response {
        Response::Ok(sub_account) => sub_account,
        Response::Err(error) => {
            panic!("Failed to create subaccount: {:?}", error)
        }
    };

    let sub_account_user = match response.data {
        Some(StatusType::Address(address)) => address,
        _ => panic!("Failed to get subaccount address: {:?}", response),
    };

    println!(
        "Subaccount created with name {} and user address: {:x} ✓",
        name, sub_account_user
    );

    tokio::time::sleep(std::time::Duration::from_secs(10)).await;

    let new_name = {
        let suffix = timestamp().to_string();

        // slice the last 4 characters
        let suffix = &suffix[suffix.len() - 4..];

        format!("Acc-{}", suffix)
    };

    println!("Renaming subaccount to: {}", new_name);

    let response = exchange
        .sub_account_modify(wallet.clone(), new_name, sub_account_user)
        .await
        .expect("Failed to rename subaccount");

    let response = match response {
        Response::Ok(sub_account) => sub_account,
        Response::Err(error) => {
            panic!("Failed to rename subaccount: {:?}", error)
        }
    };

    println!("Subaccount rename response: {:?} ✓", response);

    tokio::time::sleep(std::time::Duration::from_secs(5)).await;

    println!("Depositing 1 USD to subaccount...");

    let usd = 1_000_000;

    let is_deposit = true;

    let response = exchange
        .sub_account_transfer(wallet.clone(), is_deposit, sub_account_user, usd)
        .await
        .expect("Failed to deposit funds");

    let response = match response {
        Response::Ok(response) => response,
        Response::Err(error) => {
            panic!("Failed to deposit funds: {:?}", error)
        }
    };

    println!("Deposit response: {:?} ✓", response);

    tokio::time::sleep(std::time::Duration::from_secs(10)).await;

    println!("Withdrawing funds from subaccount...");

    let response = exchange
        .sub_account_transfer(wallet.clone(), !is_deposit, sub_account_user, usd)
        .await
        .expect("Failed to withdraw funds");

    let response = match response {
        Response::Ok(response) => response,
        Response::Err(error) => {
            panic!("Failed to withdraw funds: {:?}", error)
        }
    };

    println!("Withdraw response: {:?} ✓", response);
}

// timestamp in miliseconds using std::time::SystemTime
fn timestamp() -> u64 {
    use std::time::{SystemTime, UNIX_EPOCH};

    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis() as u64
}