df-hyperliquid-core 0.0.9-beta

Hyperliquid SDK for Rust: markets, account, trading, transfers, earn and deploy, with exact decimals and signing. Native and wasm.
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

//! `cDeposit`, `cWithdraw` and `tokenDelegate`: user-signed, keys in the order
//! `@nktkas/hyperliquid` 0.33.2 posts them.

use crate::account::{ActionKind, Signers};
use crate::utils::sign::{Field, NonceKey, UserAction, UserSigned};
use crate::utils::{Address, BadUnits, Dec, HYPE_DECIMALS, exact_units};

/// `hype` as the `wei` an action carries, refused rather than rounded when
/// it has more than eight places.
pub fn hype_wei(hype: Dec) -> Result<u64, BadUnits> {
    exact_units(hype, HYPE_DECIMALS)
}

/// `cDeposit`: HYPE from spot into the staking balance, undelegated.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CDeposit {
    wei: u64,
    nonce: u64,
}

impl CDeposit {
    /// User-signed: only the account's own key.
    pub const KEY: Signers = ActionKind::CDeposit.signers();

    pub fn new(hype: Dec, nonce: u64) -> Result<CDeposit, BadUnits> {
        Ok(CDeposit { wei: hype_wei(hype)?, nonce })
    }

    #[must_use]
    pub const fn wei(&self) -> u64 {
        self.wei
    }
}

impl UserAction for CDeposit {
    fn user_signed(&self) -> UserSigned<'_> {
        UserSigned::new("cDeposit", "HyperliquidTransaction:CDeposit", NonceKey::Nonce, self.nonce)
            .field("wei", Field::Uint64(self.wei))
    }
}

/// `cWithdraw`: undelegated HYPE from staking back toward spot, after
/// [`unstaking_ms`](crate::earn::staking::unstaking_ms) in the queue.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CWithdraw {
    wei: u64,
    nonce: u64,
}

impl CWithdraw {
    /// User-signed: only the account's own key.
    pub const KEY: Signers = ActionKind::CWithdraw.signers();

    pub fn new(hype: Dec, nonce: u64) -> Result<CWithdraw, BadUnits> {
        Ok(CWithdraw { wei: hype_wei(hype)?, nonce })
    }

    #[must_use]
    pub const fn wei(&self) -> u64 {
        self.wei
    }
}

impl UserAction for CWithdraw {
    fn user_signed(&self) -> UserSigned<'_> {
        UserSigned::new("cWithdraw", "HyperliquidTransaction:CWithdraw", NonceKey::Nonce, self.nonce)
            .field("wei", Field::Uint64(self.wei))
    }
}

/// `tokenDelegate`: staking balance to a validator, or back. A delegation is locked for
/// [`delegation_lock_ms`](crate::earn::staking::delegation_lock_ms) before it can be undelegated.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TokenDelegate {
    validator: Address,
    wei: u64,
    is_undelegate: bool,
    nonce: u64,
}

impl TokenDelegate {
    /// User-signed: only the account's own key.
    pub const KEY: Signers = ActionKind::TokenDelegate.signers();

    pub fn delegate(validator: Address, hype: Dec, nonce: u64) -> Result<TokenDelegate, BadUnits> {
        Ok(TokenDelegate { validator, wei: hype_wei(hype)?, is_undelegate: false, nonce })
    }

    pub fn undelegate(validator: Address, hype: Dec, nonce: u64) -> Result<TokenDelegate, BadUnits> {
        Ok(TokenDelegate { validator, wei: hype_wei(hype)?, is_undelegate: true, nonce })
    }

    #[must_use]
    pub const fn wei(&self) -> u64 {
        self.wei
    }
}

/// `validator` is an `address` in the typed data, posted lowercase.
impl UserAction for TokenDelegate {
    fn user_signed(&self) -> UserSigned<'_> {
        UserSigned::new("tokenDelegate", "HyperliquidTransaction:TokenDelegate", NonceKey::Nonce, self.nonce)
            .field("validator", Field::Address(self.validator))
            .field("wei", Field::Uint64(self.wei))
            .field("isUndelegate", Field::Bool(self.is_undelegate))
    }
}