kraky 0.1.2

Lightweight, production-ready Rust SDK for Kraken Exchange WebSocket API v2 with unique orderbook imbalance detection and WebSocket trading
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

//! Authentication module for Kraken WebSocket API
//!
//! This module provides HMAC-SHA256 signing for authenticated WebSocket subscriptions.
//!
//! Requires the `auth` feature flag.

use crate::error::{KrakyError, Result};
use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
use hmac::{Hmac, Mac};
use sha2::Sha256;

type HmacSha256 = Hmac<Sha256>;

/// Authentication credentials for Kraken API
#[derive(Clone)]
pub struct Credentials {
    /// API key (public)
    pub api_key: String,
    /// API secret (private, base64 encoded)
    api_secret: String,
}

impl Credentials {
    /// Create new credentials
    ///
    /// # Arguments
    /// * `api_key` - Your Kraken API key
    /// * `api_secret` - Your Kraken API secret (base64 encoded string from Kraken)
    ///
    /// # Example
    /// ```no_run
    /// use kraky::Credentials;
    ///
    /// let creds = Credentials::new(
    ///     "your_api_key_here",
    ///     "your_base64_secret_here"
    /// );
    /// ```
    pub fn new(api_key: impl Into<String>, api_secret: impl Into<String>) -> Self {
        Self {
            api_key: api_key.into(),
            api_secret: api_secret.into(),
        }
    }

    /// Generate authentication token for WebSocket subscription
    ///
    /// Uses HMAC-SHA256 to sign the request according to Kraken API specs.
    ///
    /// # Arguments
    /// * `nonce` - Unique nonce (timestamp in nanoseconds recommended)
    ///
    /// # Returns
    /// Base64-encoded HMAC signature
    pub fn generate_token(&self, nonce: u64) -> Result<String> {
        // Decode the API secret from base64
        let secret_bytes = BASE64
            .decode(&self.api_secret)
            .map_err(|e| KrakyError::InvalidMessage(format!("Invalid API secret: {}", e)))?;

        // Create the message to sign: nonce as string
        let message = nonce.to_string();

        // Create HMAC-SHA256 with the decoded secret
        let mut mac = HmacSha256::new_from_slice(&secret_bytes)
            .map_err(|e| KrakyError::InvalidMessage(format!("HMAC error: {}", e)))?;

        // Sign the message
        mac.update(message.as_bytes());

        // Get the signature
        let signature = mac.finalize().into_bytes();

        // Encode to base64
        Ok(BASE64.encode(signature))
    }

    /// Get API key
    pub fn api_key(&self) -> &str {
        &self.api_key
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_credentials_creation() {
        let creds = Credentials::new("test_key", "dGVzdF9zZWNyZXQ=");
        assert_eq!(creds.api_key(), "test_key");
    }

    #[test]
    fn test_token_generation() {
        // Test with a valid base64 secret
        let creds = Credentials::new("test_key", "dGVzdF9zZWNyZXQ=");
        let token = creds.generate_token(1234567890);
        assert!(token.is_ok());
        assert!(!token.unwrap().is_empty());
    }

    #[test]
    fn test_invalid_secret() {
        // Test with invalid base64
        let creds = Credentials::new("test_key", "not-valid-base64!");
        let token = creds.generate_token(1234567890);
        assert!(token.is_err());
    }

    #[test]
    fn test_deterministic_signing() {
        // Same nonce should produce same signature
        let creds = Credentials::new("test_key", "dGVzdF9zZWNyZXQ=");
        let token1 = creds.generate_token(1234567890).unwrap();
        let token2 = creds.generate_token(1234567890).unwrap();
        assert_eq!(token1, token2);
    }

    #[test]
    fn test_different_nonces() {
        // Different nonces should produce different signatures
        let creds = Credentials::new("test_key", "dGVzdF9zZWNyZXQ=");
        let token1 = creds.generate_token(1234567890).unwrap();
        let token2 = creds.generate_token(9876543210).unwrap();
        assert_ne!(token1, token2);
    }
}